From 7e5a0dd3399d280b55143bfe272eafe92019cf53 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 2 Jan 2025 18:53:12 +0100
Subject: [PATCH 001/116] Parse relocatable file (hacky handling of
 relocations)

---
 notes-TODO                    |  3 +++
 src/analyse/ControlFlow.ml    |  4 +--
 src/analyse/Elf.ml            |  2 +-
 src/bin/copySources.ml        |  4 +--
 src/dw/dw.ml                  |  2 +-
 src/elf/file.ml               | 47 ++++++++++++++---------------------
 src/elf/linksemRelocatable.ml | 39 +++++++++++++++++++++++++++++
 src/elf/symTable.ml           | 12 ++++-----
 src/elf/symTable.mli          |  4 +--
 src/elf/symbol.ml             | 38 +++++++++++++++++-----------
 src/elf/symbol.mli            | 13 +++++++---
 11 files changed, 109 insertions(+), 59 deletions(-)
 create mode 100644 notes-TODO
 create mode 100644 src/elf/linksemRelocatable.ml

diff --git a/notes-TODO b/notes-TODO
new file mode 100644
index 00000000..c8e943ae
--- /dev/null
+++ b/notes-TODO
@@ -0,0 +1,3 @@
+Symbolic symbol table
+- value of symbol?? (we don't have segments in relocatable files)
+- can probably keep the same api, but addresses are symbolic
\ No newline at end of file
diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 166a80c3..9d9628c0 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -132,14 +132,14 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
 
   (* pull out .rodata section from ELF *)
   let ((_, rodata_addr, bs) as _rodata : Dwarf.p_context * Nat_big_num.num * BytesSeq.t) =
-    Dwarf.extract_section_body test.elf_file ".rodata" false
+    Dwarf.extract_section_body_without_relocations test.elf_file ".rodata" false
   in
   (* chop into bytes *)
   let rodata_bytes : char array = BytesSeq.to_array bs in
 
   (* chop into 4-byte words - as needed for branch offset tables,
      though not for all other things in .rodata *)
-  let rodata_words : (natural * natural) list = Dwarf.words_of_byte_sequence rodata_addr bs [] in
+  let rodata_words : (natural * natural) list = Dwarf.words_of_rel_byte_sequence rodata_addr (Dwarf.rbs_no_reloc bs) [] in (*HACK*)
 
   let read_rodata_b addr =
     Elf_types_native_uint.natural_of_byte
diff --git a/src/analyse/Elf.ml b/src/analyse/Elf.ml
index 0be22494..4b4bfc9b 100644
--- a/src/analyse/Elf.ml
+++ b/src/analyse/Elf.ml
@@ -143,7 +143,7 @@ let parse_elf_file (filename : string) : test =
           segments
       in
       let ds =
-        match Dwarf.extract_dwarf_static (Elf_file.ELF_File_64 f1) with
+        match Dwarf.extract_dwarf_static (Elf_file.ELF_File_64 f1) Abi_aarch64_symbolic_relocation.aarch64_data_relocation_interpreter with
         | None -> fatal "%s" "extract_dwarf_static failed"
         | Some ds ->
             (* Debug.print_string2 (Dwarf.pp_analysed_location_data ds.Dwarf.ds_dwarf
diff --git a/src/bin/copySources.ml b/src/bin/copySources.ml
index d664698c..094d3257 100644
--- a/src/bin/copySources.ml
+++ b/src/bin/copySources.ml
@@ -84,8 +84,8 @@ let process_file () : unit =
                else
                  Some
                    (Byte_sequence.string_of_byte_sequence
-                      (List.nth lnh.lnh_include_directories (dir - 1)))),
-              Byte_sequence.string_of_byte_sequence lnfe.lnfe_path ))
+                      (rbs_unwrap (List.nth lnh.lnh_include_directories (dir - 1))))),
+              Byte_sequence.string_of_byte_sequence (rbs_unwrap lnfe.lnfe_path) ))
       lnh.lnh_file_entries
   in
 
diff --git a/src/dw/dw.ml b/src/dw/dw.ml
index 270c3576..af505b53 100644
--- a/src/dw/dw.ml
+++ b/src/dw/dw.ml
@@ -85,7 +85,7 @@ let of_elf (elf : Elf.File.t) =
   Arch.load_elf_arch elf;
   info "Extracting dwarf of %s" elf.filename;
   let ldwarf =
-    match Dwarf.extract_dwarf elf.linksem with
+    match Dwarf.extract_dwarf elf.linksem Abi_aarch64_symbolic_relocation.aarch64_data_relocation_interpreter with
     | Some d -> d
     | None -> dwarferror "Linksem extract_dwarf failed"
   in
diff --git a/src/elf/file.ml b/src/elf/file.ml
index 4b49c026..e3d8925d 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -105,49 +105,40 @@ let elferror fmt = Printf.ksprintf (fun s -> raise (ElfError s)) fmt
 let of_file (filename : string) =
   info "Loading ELF file %s" filename;
   (* parse the ELF file using linksem *)
-  let ( (elf_file : Elf_file.elf_file),
+  let bs = match Byte_sequence.acquire filename with
+    | Error.Fail s -> elferror "Linksem: Byte_sequence.acquire: %s" s
+    | Error.Success x -> x
+  in
+  let elf64_file = match Elf_file.read_elf64_file bs with
+    | Error.Fail s -> elferror "Linksem: read_elf64_file: %s" s
+    | Error.Success x -> x
+  in
+  let symbol_map = match LinksemRelocatable.get_elf64_file_global_symbol_init elf64_file with
+    | Error.Fail s -> elferror "LinksemRelocatable: get_elf64_file_global_symbol_init: %s" s
+    | Error.Success x -> x
+  in
+  (* let ( (elf_file : Elf_file.elf_file),
         (elf_epi : Sail_interface.executable_process_image),
         (symbol_map : Elf_file.global_symbol_init_info) ) =
     match Sail_interface.populate_and_obtain_global_symbol_init_info filename with
     | Error.Fail s -> elferror "Linksem: populate_and_obtain_global_symbol_init_info: %s" s
     | Error.Success x -> x
-  in
+  in *)
   (* Check this is a 64 bits ELF file *)
-  begin
-    match elf_file with
-    | Elf_file.ELF_File_32 _ -> elferror "32 bits elf files unsupported"
-    | _ -> ()
-  end;
-  let (segments, entry, machine) =
-    match elf_epi with
-    | ELF_Class_32 _ -> elferror "32 bits elf file class unsupported"
-    | ELF_Class_64 (s, e, m) -> (s, e, m)
-  in
-
-  (* Extract all the segments *)
-  let segments =
-    List.filter_map
-      (fun (seg, prov) -> if prov = Elf_file.FromELF then Some seg else None)
-      segments
-  in
-  let entry = Z.to_int entry in
-  let machine = machine_of_linksem machine in
-  debug "Loading ELF segments of %s" filename;
-  let segments = List.map Segment.of_linksem segments in
-  debug "Loaded ELF segments %t"
-  @@ Pp.top (Pp.list Pp.hex)
-  @@ List.map (fun x -> x.Segment.addr) segments;
+  let entry = Z.to_int elf64_file.elf64_file_header.elf64_entry in
+  let machine = machine_of_linksem elf64_file.elf64_file_header.elf64_machine in
   debug "Loading ELF symbols of %s" filename;
-  let symbols = SymTbl.of_linksem segments symbol_map in
+  let symbols = SymTbl.of_linksem symbol_map in
   debug "Adding .rodata section of %s" filename;
   (* We add the .rodata section seperately from the symbols because
      - it can contain non-symbol information such as string literals and
        constants used in branch-register target calculations
      - the range of the section is guaranteed to overlap with any symbols
        within it, and so not suitable to be stored in the [RngMap] *)
+  let elf_file = Elf_file.ELF_File_64 elf64_file in
   let rodata =
     let (_, addr, data) =
-      Dwarf.extract_section_body elf_file ".rodata" false
+      Dwarf.extract_section_body_without_relocations elf_file ".rodata" false
       (* `false' argument is for returning an empty byte-sequence if
          section is not found, instead of throwing an exception *)
     in
diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
new file mode 100644
index 00000000..82b4e035
--- /dev/null
+++ b/src/elf/linksemRelocatable.ml
@@ -0,0 +1,39 @@
+(* TODO header *)
+
+type sym_addr = string * Z.t
+
+(* Like in linksem, but address is section+offset, and with a writable flag *)
+type symbol = string * (Z.t * Z.t * sym_addr * Byte_sequence_wrapper.byte_sequence * Z.t) * bool
+
+type global_symbol_init_info = symbol list
+
+open Elf_symbol_table
+open Elf_interpreted_section
+
+let get_elf64_file_global_symbol_init f : global_symbol_init_info Error.error =
+  let secs = f.Elf_file.elf64_file_interpreted_sections in
+  Error.bind (Elf_file.get_elf64_file_symbol_table f) (fun (symtab, strtab) ->
+    List.filter_map (
+      fun entry ->
+        let name = Uint32_wrapper.to_bigint entry.elf64_st_name in
+        let addr_offset = Uint64_wrapper.to_bigint entry.elf64_st_value in
+        let size = Uint64_wrapper.to_bigint entry.elf64_st_size in
+        let shndx = Uint32_wrapper.to_int entry.elf64_st_shndx in
+        let typ  = Elf_symbol_table.extract_symbol_type entry.elf64_st_info in
+        let bnd  = Elf_symbol_table.extract_symbol_binding entry.elf64_st_info in
+        Option.map (
+          fun section ->
+            let addr = (section.elf64_section_name_as_string, addr_offset) in
+            let data = if Byte_sequence.length0 section.elf64_section_body = Z.zero then
+              Error.return (Byte_sequence.zeros size)
+            else
+              Byte_sequence.offset_and_cut addr_offset size section.elf64_section_body
+            in
+            Error.bind data (fun data ->
+            Error.bind (String_table.get_string_at name strtab) (fun str ->
+              let write = Elf_file.flag_is_set Elf_section_header_table.shf_write section.elf64_section_flags in
+              Error.return (str, (typ, size, addr, data, bnd), write)
+            ))
+        ) (List.nth_opt secs shndx)
+    ) symtab |> Error.mapM Fun.id
+  )
\ No newline at end of file
diff --git a/src/elf/symTable.ml b/src/elf/symTable.ml
index d1b2ecd7..8ef56b4d 100644
--- a/src/elf/symTable.ml
+++ b/src/elf/symTable.ml
@@ -59,7 +59,7 @@ type sym_offset = sym * int
 module RMap = RngMap.Make (Symbol)
 module SMap = Map.Make (String)
 
-type linksem_t = Elf_file.global_symbol_init_info
+type linksem_t = LinksemRelocatable.global_symbol_init_info
 
 type t = { by_name : sym SMap.t; by_addr : RMap.t }
 
@@ -111,11 +111,11 @@ let of_position_string t s : sym_offset =
   if s = "" then raise Not_found;
   if s.[0] = '0' then of_addr_with_offset t (int_of_string s) else sym_offset_of_string t s
 
-let of_linksem segments linksem_map =
-  let add_linksem_sym_to_map (map : t) (lsym : linksem_sym) =
-    if is_interesting_linksem lsym then add map (Symbol.of_linksem segments lsym) else map
-  in
-  List.fold_left add_linksem_sym_to_map empty linksem_map
+  let of_linksem linksem_map =
+    let add_linksem_sym_to_map (map : t) (lsym : linksem_sym) =
+      if is_interesting_linksem lsym then add map (Symbol.of_linksem lsym) else map
+    in
+    List.fold_left add_linksem_sym_to_map empty linksem_map
 
 let pp_raw st = RMap.bindings st.by_addr |> List.map (Pair.map Pp.ptr pp_raw) |> Pp.mapping "syms"
 
diff --git a/src/elf/symTable.mli b/src/elf/symTable.mli
index bcd57ca5..8cb35435 100644
--- a/src/elf/symTable.mli
+++ b/src/elf/symTable.mli
@@ -57,7 +57,7 @@ type linksem_sym = Symbol.linksem_t
 (** The type of a symbol with offset *)
 type sym_offset = sym * int
 
-type linksem_t = Elf_file.global_symbol_init_info
+type linksem_t = LinksemRelocatable.global_symbol_init_info
 
 (** The type of a symbol table. *)
 type t
@@ -110,7 +110,7 @@ val of_position_string : t -> string -> sym_offset
 (** Extract the symbol from the linksem symbol representation.
 
     Need the segments for filling the missing symbol data *)
-val of_linksem : Segment.t list -> linksem_t -> t
+val of_linksem : linksem_t -> t
 
 (** Pretty print the table as a raw ocaml value *)
 val pp_raw : t -> Pp.document
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 439dc0ec..d6e0baa3 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -42,27 +42,38 @@
 (*                                                                                  *)
 (*==================================================================================*)
 
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
 (* The documentation is in the mli file *)
 
 type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
+(* TODO: move somewhere to reuse *)
+type addr = {
+  section : string;
+  offset: int;
+}
+
 type t = {
   name : string;
   other_names : string list;
   typ : typ;
+  (* addr : addr; *)
   addr : int;
   size : int;
   writable : bool;
   data : BytesSeq.t;
 }
 
-type linksem_t = string * (Z.t * Z.t * Z.t * BytesSeq.t option * Z.t)
+type linksem_t = LinksemRelocatable.symbol
 
 let push_name s t = { t with other_names = s :: t.other_names }
 
-let is_in t addr = t.addr <= addr && addr < t.addr + t.size
+(* let is_in t addr = t.addr <= addr && addr < t.addr + t.size *)
 
 let len t = t.size
 
@@ -75,7 +86,7 @@ let typ_of_linksem ltyp =
   | 4 -> FILE
   | _ -> UNKNOWN
 
-let linksem_typ (_name, (typ, _size, _addr, _data, _)) = typ
+let linksem_typ (_name, (typ, _size, _addr, _data, _), _) = typ
 
 (** [LoadingError(name,addr)] means that symbol [name] at [addr] could not be loaded *)
 exception LoadingError of string * int
@@ -86,19 +97,17 @@ let _ =
         Some (Printf.sprintf "Symbol %s at 0x%x could not be loaded" name addr)
     | _ -> None)
 
-let of_linksem segs (name, (typ, size, addr, data, _)) =
+(* for debugging TODO remove *)
+module SMap = Map.Make (String)
+let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000
+
+let of_linksem (name, (typ, size, addr, data, _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
-  let addr = Z.to_int addr in
-  let segment =
-    Option.value_fail (Segment.get_containing segs addr) "No segment contains symbol %s" name
-  in
-  let writable = segment.write in
-  let data =
-    data
-    |> Option.value_fun ~default:(fun () ->
-           Segment.get_addr (BytesSeq.getbs ~len:size) segment addr)
-  in
+  let section, offset = addr in
+  (* let addr = { section; offset = Z.to_int offset } in *)
+  let addr = SMap.find section locs + Z.to_int offset in
+  debug "Symbol %s at address %s+%d (using %d)" name section (Z.to_int offset) addr;
   { name; other_names = []; typ; size; addr; data; writable }
 
 let is_interesting = function OBJECT | FUNC -> true | _ -> false
@@ -128,6 +137,7 @@ let pp_raw sym =
            ("name", !^(sym.name));
            ("other names", separate nbspace (List.map string sym.other_names));
            ("typ", pp_typ sym.typ);
+           (* ("addr", !^(sym.addr.section) ^^ !^"+" ^^ ptr sym.addr.offset); *)
            ("addr", ptr sym.addr);
            ("size", ptr sym.size);
            ("writable", bool sym.writable);
diff --git a/src/elf/symbol.mli b/src/elf/symbol.mli
index e557439f..51213545 100644
--- a/src/elf/symbol.mli
+++ b/src/elf/symbol.mli
@@ -55,12 +55,19 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
+(* TODO: move somewhere to reuse *)
+type addr = {
+  section : string;
+  offset: int;
+}
+
 (** The ELF symbol. This type guarantee the data exists contrary to linksem symbols
     (it may be all zeros though) *)
 type t = {
   name : string;
   other_names : string list;
   typ : typ;
+  (* addr : addr; *)
   addr : int;
   size : int;
   writable : bool;
@@ -68,13 +75,13 @@ type t = {
 }
 
 (** The type of an ELF symbol in linksem. See {!of_linksem}*)
-type linksem_t = string * (Z.t * Z.t * Z.t * BytesSeq.t option * Z.t)
+type linksem_t = LinksemRelocatable.symbol
 
 (** Add a name to the other names list *)
 val push_name : string -> t -> t
 
 (** Check if an address is in a symbol *)
-val is_in : t -> int -> bool
+(* val is_in : t -> int -> bool *)
 
 (** For conformance with the {!Utils.RngMap.LenObject} module type *)
 val len : t -> int
@@ -93,7 +100,7 @@ exception LoadingError of string * int
     May raise {!LoadingError} when the symbol has no data and the
     data cannot be found in the segments
 *)
-val of_linksem : Segment.t list -> linksem_t -> t
+val of_linksem : linksem_t -> t
 
 (** Tell if a symbol type is interesting for readDwarf purposes *)
 val is_interesting : typ -> bool

From ecb6af3cd66655757460144e55ca559f2435a482 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 3 Jan 2025 18:20:24 +0100
Subject: [PATCH 002/116] Update config

---
 src/config/isla_aarch64.toml | 150 ++++++++---------------------------
 1 file changed, 35 insertions(+), 115 deletions(-)

diff --git a/src/config/isla_aarch64.toml b/src/config/isla_aarch64.toml
index cf209041..27d6e500 100644
--- a/src/config/isla_aarch64.toml
+++ b/src/config/isla_aarch64.toml
@@ -1,61 +1,24 @@
-#==================================================================================#
-#  BSD 2-Clause License                                                            #
-#                                                                                  #
-#  Copyright (c) 2020-2021 Thibaut Pérami                                          #
-#  Copyright (c) 2020-2021 Dhruv Makwana                                           #
-#  Copyright (c) 2019-2021 Peter Sewell                                            #
-#  All rights reserved.                                                            #
-#                                                                                  #
-#  This software was developed by the University of Cambridge Computer             #
-#  Laboratory as part of the Rigorous Engineering of Mainstream Systems            #
-#  (REMS) project.                                                                 #
-#                                                                                  #
-#  This project has been partly funded by EPSRC grant EP/K008528/1.                #
-#  This project has received funding from the European Research Council            #
-#  (ERC) under the European Union's Horizon 2020 research and innovation           #
-#  programme (grant agreement No 789108, ERC Advanced Grant ELVER).                #
-#  This project has been partly funded by an EPSRC Doctoral Training studentship.  #
-#  This project has been partly funded by Google.                                  #
-#                                                                                  #
-#  Redistribution and use in source and binary forms, with or without              #
-#  modification, are permitted provided that the following conditions              #
-#  are met:                                                                        #
-#  1. Redistributions of source code must retain the above copyright               #
-#     notice, this list of conditions and the following disclaimer.                #
-#  2. Redistributions in binary form must reproduce the above copyright            #
-#     notice, this list of conditions and the following disclaimer in              #
-#     the documentation and/or other materials provided with the                   #
-#     distribution.                                                                #
-#                                                                                  #
-#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''              #
-#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED               #
-#  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A                 #
-#  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR             #
-#  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,                    #
-#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT                #
-#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF                #
-#  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND             #
-#  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,              #
-#  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT              #
-#  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF              #
-#  SUCH DAMAGE.                                                                    #
-#                                                                                  #
-#==================================================================================#
-
 # This is a config file for the Sail generated from ARM-ASL
-# It is copied from the Isla repo and should be synced periodically.
-# It probably contains a lot of stuff that's not needed for read-dwarf.
 
 pc = "_PC"
 
 ifetch = "Read_ifetch"
 
-read_exclusives = ["Read_exclusive", "Read_exclusive_acquire"]
-write_exclusives = ["Write_exclusive", "Write_exclusive_release"]
+in_program_order = ["sail_barrier"]
 
 # The assembler is used for assembling the code in litmus tests. We
 # assume it takes arguments like GNU as.
-assembler = "aarch64-linux-gnu-as -march=armv8.3-a" # read-dwarf
+[[toolchain]]
+name = "macos-aarch64"
+os = "macos"
+arch = "aarch64"
+assembler = "as --target=aarch64-unknown-linux-gnu"
+objdump = "/opt/homebrew/opt/llvm/bin/llvm-objdump"
+linker = "/opt/homebrew/opt/llvm/bin/ld.lld"
+
+[[toolchain]]
+name = "default"
+assembler = "aarch64-linux-gnu-as -march=armv8.1-a"
 objdump = "aarch64-linux-gnu-objdump"
 linker = "aarch64-linux-gnu-ld"
 
@@ -84,6 +47,8 @@ stride = "0x10"
 
 [registers]
 ignore = [
+  "_PC",
+  "__PC_changed",
   "SEE",
   "__unconditional",
   "__trickbox_enabled",
@@ -91,25 +56,15 @@ ignore = [
   "__v82_implemented",
   "__v83_implemented",
   "__v84_implemented",
-  "__v85_implemented",
-  "_GTEExtObsAccess",
-  "_GTEExtObsActive",
-  "_GTEExtObsAddress",
-  "_GTEExtObsCount",
-  "_GTEExtObsData",
-  "_GTEExtObsIndex",
-  "_GTEExtObsResult",
-  "_GTEExtObsResultIndex",
-  "_GTEExtObsResultIsAddress",
-  "_GTE_PPU_Access",
-  "_GTE_PPU_Address",
-  "_GTE_PPU_SizeEn"
+  "__v85_implemented"
 ]
 
 # These registers are set before any symbolic execution occurs
 [registers.defaults]
-"__isla_monomorphize_reads" = false
-"__isla_monomorphize_writes" = false
+"__isla_vector_gpr" = false
+"__isla_continue_on_see" = true
+"__monomorphize_reads" = false
+"__monomorphize_writes" = false
 "VBAR_EL1" = "0x0000000000000000"
 "VBAR_EL2" = "0x0000000000000000"
 # Causes CNTCV to be incremented every cycle if bit 0 is 1
@@ -117,6 +72,7 @@ ignore = [
 # SSAdvance?
 "MDSCR_EL1" = "0x00000000"
 "InGuardedPage" = false
+"__highest_el_aarch32" = false
 "__currentInstrLength" = 4
 "_PendingPhysicalSE" = false
 "__CNTControlBase" = "0x0000000000000"
@@ -129,19 +85,18 @@ ignore = [
 "CFG_RMR_AA64" = "0b1"
 "CFG_RVBAR" = "0x0000000010300000"
 "CFG_ID_AA64PFR0_EL1_MPAM" = "0x1"
-"CFG_ID_AA64PFR0_EL1_EL3" = "0x2"
-"CFG_ID_AA64PFR0_EL1_EL2" = "0x2"
-"CFG_ID_AA64PFR0_EL1_EL1" = "0x2"
-"CFG_ID_AA64PFR0_EL1_EL0" = "0x2"
+"CFG_ID_AA64PFR0_EL1_EL3" = "0x1"
+"CFG_ID_AA64PFR0_EL1_EL2" = "0x1"
+"CFG_ID_AA64PFR0_EL1_EL1" = "0x1"
+"CFG_ID_AA64PFR0_EL1_EL0" = "0x1"
 # Need to investigate BTI extension. Guard pages cause problems with
 # memory accesses.
 "__v81_implemented" = true
-"__v82_implemented" = true # read-dwarf
-"__v83_implemented" = true # read-dwarf
+"__v82_implemented" = false
+"__v83_implemented" = false
 "__v84_implemented" = false
 "__v85_implemented" = false
 "__unpred_tsize_aborts" = true
-"exclusive_never_fails" = true # read-dwarf
 # Trickbox has various features for debugging spec and running tests
 "__trickbox_enabled" = false
 "__tlb_enabled" = false
@@ -173,12 +128,19 @@ ignore = [
 "__crypto_sm3_implemented" = false
 "__crypto_sha512_implemented" = false
 "__crypto_sha3_implemented" = false
+"_GTEExtObsAccess" = "[0x0000; 256]"
+"_GTEExtObsAddress" = "[0x0000000000000000; 256]"
+"_GTEExtObsData" = "[0x0000000000000000; 256]"
+"_GTEExtObsResult" = "[0x0000000000000000; 256]"
+"_GTE_PPU_SizeEn" = "[0x00000000; 6]"
+"_GTE_PPU_Address" = "[0x0000000000000000; 6]"
+"_GTE_PPU_Access" = "[0x00000000; 6]"
 
 # These registers are set during symbolic execution by the special builtin "reset_registers"
 [registers.reset]
-# Bit 1 being set causes us to abort on unaligned accesses
+# Bit 1 being unset allows unaligned accesses
 # Bit 26 being set allows cache-maintenance ops in EL0
-"SCTLR_EL1" = "0x0000000004000002"
+"SCTLR_EL1" = "0x0000000004000000"
 
 # A map from register names that may appear in litmus files to Sail
 # register names
@@ -245,45 +207,3 @@ ignore = [
 "W28" = "R28"
 "W29" = "R29"
 "W30" = "R30"
-
-[reads]
-Read_acquire = "A"
-Read_exclusive_acquire = "A"
-
-[writes]
-Write_release = "L"
-Write_exclusive_release = "L"
-
-[cache_ops]
-Cache_op_D_CVAU = "DC"
-Cache_op_I_IVAU = "IC"
-Cache_op_I_IALLU = "IC"
-
-# A mapping from Sail barrier_kinds for the spec to the names in cat
-# memory models.
-[barriers]
-Barrier_DMB_SY = "DMB.SY"
-Barrier_DMB_ST = "DMB.ST"
-Barrier_DMB_LD = "DMB.LD"
-Barrier_DMB_ISH = "DMB.ISH"
-Barrier_DMB_ISHST = "DMB.ISHST"
-Barrier_DMB_ISHLD = "DMB.ISHLD"
-Barrier_DMB_NSH = "DMB.NSH"
-Barrier_DMB_NSHST = "DMB.NSHST"
-Barrier_DMB_NSHLD = "DMB.NSHLD"
-Barrier_DMB_OSH = "DMB.OSH"
-Barrier_DMB_OSHST = "DMB.OSHST"
-Barrier_DMB_OSHLD = "DMB.OSHLD"
-Barrier_DSB_SY = "DSB.SY"
-Barrier_DSB_ST = "DSB.ST"
-Barrier_DSB_LD = "DSB.LD"
-Barrier_DSB_ISH = "DSB.ISH"
-Barrier_DSB_ISHST = "DSB.ISHST"
-Barrier_DSB_ISHLD = "DSB.ISHLD"
-Barrier_DSB_NSH = "DSB.NSH"
-Barrier_DSB_NSHST = "DSB.NSHST"
-Barrier_DSB_NSHLD = "DSB.NSHLD"
-Barrier_DSB_OSH = "DSB.OSH"
-Barrier_DSB_OSHST = "DSB.OSHST"
-Barrier_DSB_OSHLD = "DSB.OSHLD"
-Barrier_ISB = "ISB"

From 7514a8a69385deba347330a860e338d4ce078b1a Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 4 Jan 2025 19:31:52 +0100
Subject: [PATCH 003/116] Symbolic symbol table

---
 src/elf/symTable.ml  | 71 ++++++++++++++++++++++++++++++++++----------
 src/elf/symTable.mli | 10 +++----
 src/elf/symbol.ml    | 19 ++++++------
 src/elf/symbol.mli   |  7 +++--
 4 files changed, 75 insertions(+), 32 deletions(-)

diff --git a/src/elf/symTable.ml b/src/elf/symTable.ml
index 8ef56b4d..dee03749 100644
--- a/src/elf/symTable.ml
+++ b/src/elf/symTable.ml
@@ -59,19 +59,57 @@ type sym_offset = sym * int
 module RMap = RngMap.Make (Symbol)
 module SMap = Map.Make (String)
 
+module AddrMap = struct
+  type t = RMap.t SMap.t
+
+  let add t addr sym =
+    SMap.update addr.section (fun old ->
+      let old = match old with
+      | None -> RMap.empty
+      | Some x -> x
+      in
+      Some (RMap.add old addr.offset sym)
+    ) t
+  
+  let update f t addr =
+    SMap.update addr.section (Option.map (fun x -> RMap.update f x addr.offset)) t
+  
+  let empty = SMap.empty
+
+  let at t addr =
+    SMap.find addr.section t |> Fun.flip RMap.at addr.offset
+
+  let at_opt t addr =
+    Option.bind (SMap.find_opt addr.section t) @@ Fun.flip RMap.at_opt addr.offset
+  
+  let at_off t addr =
+    SMap.find addr.section t |> Fun.flip RMap.at_off addr.offset
+  
+  let at_off_opt t addr =
+    Option.bind (SMap.find_opt addr.section t) @@ Fun.flip RMap.at_off_opt addr.offset
+  
+  let bindings t =
+    let sections = SMap.bindings t in
+    List.bind sections @@ fun (section, rmap) ->
+      let inner_bindings = RMap.bindings rmap in
+      List.map (fun (offset, sym) -> ({section; offset}, sym)) inner_bindings
+  
+  
+end
+
 type linksem_t = LinksemRelocatable.global_symbol_init_info
 
-type t = { by_name : sym SMap.t; by_addr : RMap.t }
+type t = { by_name : sym SMap.t; by_addr : AddrMap.t }
 
-let empty = { by_name = SMap.empty; by_addr = RMap.empty }
+let empty = { by_name = SMap.empty; by_addr = AddrMap.empty }
 
 let add t sym =
   let by_name = SMap.add sym.name sym t.by_name in
-  try { by_name; by_addr = RMap.add t.by_addr sym.addr sym }
+  try { by_name; by_addr = AddrMap.add t.by_addr sym.addr sym }
   with Invalid_argument _ ->
     let updated = ref false in
     let by_addr =
-      RMap.update
+      AddrMap.update
         (fun usym ->
           if usym.addr = sym.addr && usym.size = sym.size then begin
             updated := true;
@@ -88,15 +126,15 @@ let of_name t name =
 
 let of_name_opt t name = SMap.find_opt name t.by_name
 
-let of_addr t addr = RMap.at t.by_addr addr
+let of_addr t addr = AddrMap.at t.by_addr addr
 
-let of_addr_opt t addr = RMap.at_opt t.by_addr addr
+let of_addr_opt t addr = AddrMap.at_opt t.by_addr addr
 
-let of_addr_with_offset t addr = RMap.at_off t.by_addr addr
+let of_addr_with_offset t addr = AddrMap.at_off t.by_addr addr
 
-let of_addr_with_offset_opt t addr = RMap.at_off_opt t.by_addr addr
+let of_addr_with_offset_opt t addr = AddrMap.at_off_opt t.by_addr addr
 
-let to_addr_offset (sym, offset) = sym.addr + offset
+let to_addr_offset (sym, offset) = { section = sym.addr.section; offset = sym.addr.offset + offset }
 
 let string_of_sym_offset ((sym, off) : sym_offset) = sym.name ^ "+" ^ string_of_int off
 
@@ -109,15 +147,16 @@ let sym_offset_of_string t s : sym_offset =
 let of_position_string t s : sym_offset =
   let s = String.trim s in
   if s = "" then raise Not_found;
-  if s.[0] = '0' then of_addr_with_offset t (int_of_string s) else sym_offset_of_string t s
+  if s.[0] = '0' then raise Not_found (* no absolute addresses *)
+  else sym_offset_of_string t s
 
-  let of_linksem linksem_map =
-    let add_linksem_sym_to_map (map : t) (lsym : linksem_sym) =
-      if is_interesting_linksem lsym then add map (Symbol.of_linksem lsym) else map
-    in
-    List.fold_left add_linksem_sym_to_map empty linksem_map
+let of_linksem linksem_map =
+  let add_linksem_sym_to_map (map : t) (lsym : linksem_sym) =
+    if is_interesting_linksem lsym then add map (Symbol.of_linksem lsym) else map
+  in
+  List.fold_left add_linksem_sym_to_map empty linksem_map
 
-let pp_raw st = RMap.bindings st.by_addr |> List.map (Pair.map Pp.ptr pp_raw) |> Pp.mapping "syms"
+let pp_raw st = AddrMap.bindings st.by_addr |> List.map (Pair.map pp_addr pp_raw) |> Pp.mapping "syms"
 
 let iter t f = SMap.iter (fun _ value -> f value) t.by_name
 
diff --git a/src/elf/symTable.mli b/src/elf/symTable.mli
index 8cb35435..0b919a8a 100644
--- a/src/elf/symTable.mli
+++ b/src/elf/symTable.mli
@@ -78,19 +78,19 @@ val of_name_opt : t -> string -> sym option
 
 (** Get the symbol owning that address. Not_found is raised if no symbol own that address.data
       See {!of_addr_opt} *)
-val of_addr : t -> int -> sym
+val of_addr : t -> Symbol.addr -> sym
 
 (** Get the symbol owning that address. None if no symbol own that address. See {!of_addr} *)
-val of_addr_opt : t -> int -> sym option
+val of_addr_opt : t -> Symbol.addr -> sym option
 
 (** Get a symbol with the offset that correspond to that address *)
-val of_addr_with_offset : t -> int -> sym_offset
+val of_addr_with_offset : t -> Symbol.addr -> sym_offset
 
 (** Get a symbol with the offset that correspond to that address *)
-val of_addr_with_offset_opt : t -> int -> sym_offset option
+val of_addr_with_offset_opt : t -> Symbol.addr -> sym_offset option
 
 (** Get back the raw address from a symbol+offset value *)
-val to_addr_offset : sym_offset -> int
+val to_addr_offset : sym_offset -> Symbol.addr
 
 (** Transform a symbol + offset into the corresponding string *)
 val string_of_sym_offset : sym_offset -> string
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index d6e0baa3..bcbd00ae 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -62,8 +62,8 @@ type t = {
   name : string;
   other_names : string list;
   typ : typ;
-  (* addr : addr; *)
-  addr : int;
+  addr : addr;
+  (* addr : int; *)
   size : int;
   writable : bool;
   data : BytesSeq.t;
@@ -98,16 +98,15 @@ let _ =
     | _ -> None)
 
 (* for debugging TODO remove *)
-module SMap = Map.Make (String)
-let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000
+(* module SMap = Map.Make (String)
+let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000 *)
 
 let of_linksem (name, (typ, size, addr, data, _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
   let section, offset = addr in
-  (* let addr = { section; offset = Z.to_int offset } in *)
-  let addr = SMap.find section locs + Z.to_int offset in
-  debug "Symbol %s at address %s+%d (using %d)" name section (Z.to_int offset) addr;
+  let addr = { section; offset = Z.to_int offset } in
+  (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
 
 let is_interesting = function OBJECT | FUNC -> true | _ -> false
@@ -129,6 +128,8 @@ let pp_typ typ =
   | FILE -> "FILE"
   | UNKNOWN -> "UNKNOWN"
 
+let pp_addr addr = Pp.(!^(addr.section) ^^ !^"+" ^^ ptr addr.offset)
+
 let pp_raw sym =
   Pp.(
     !^"sym"
@@ -137,8 +138,8 @@ let pp_raw sym =
            ("name", !^(sym.name));
            ("other names", separate nbspace (List.map string sym.other_names));
            ("typ", pp_typ sym.typ);
-           (* ("addr", !^(sym.addr.section) ^^ !^"+" ^^ ptr sym.addr.offset); *)
-           ("addr", ptr sym.addr);
+           ("addr", pp_addr sym.addr);
+           (* ("addr", ptr sym.addr); *)
            ("size", ptr sym.size);
            ("writable", bool sym.writable);
            ("data", BytesSeq.ppby ~by:4 sym.data);
diff --git a/src/elf/symbol.mli b/src/elf/symbol.mli
index 51213545..5b5e9e6f 100644
--- a/src/elf/symbol.mli
+++ b/src/elf/symbol.mli
@@ -67,8 +67,8 @@ type t = {
   name : string;
   other_names : string list;
   typ : typ;
-  (* addr : addr; *)
-  addr : int;
+  addr : addr;
+  (* addr : int; *)
   size : int;
   writable : bool;
   data : BytesSeq.t;
@@ -117,5 +117,8 @@ val compare : t -> t -> int
 (** Pretty prints a symbol type *)
 val pp_typ : typ -> Pp.document
 
+(** Pretty prints symbolic address *)
+val pp_addr : addr -> Pp.document
+
 (** Raw pretty printing of a symbol *)
 val pp_raw : t -> Pp.document

From 58091d76021cef4260b7823208af12a57841c6bf Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 4 Jan 2025 20:14:36 +0100
Subject: [PATCH 004/116] Convert to symbolic addresses to make things compile

TODO complete the logic
---
 src/dw/func.ml    | 3 ++-
 src/dw/loc.ml     | 3 ++-
 src/state/base.ml | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/dw/func.ml b/src/dw/func.ml
index 32f64174..e8738d24 100644
--- a/src/dw/func.ml
+++ b/src/dw/func.ml
@@ -140,7 +140,8 @@ let of_linksem (elf : Elf.File.t) (tenv : Ctype.env) (lfun : linksem_t) =
     | None -> (
         match lfun.ss_entry_address with
         | Some a -> (
-            match Elf.SymTable.of_addr_opt elf.symbols (Nat_big_num.to_int a) with
+            let addr = Elf.Symbol.{section = ".text"; offset = Nat_big_num.to_int a} in (* TODO this is wrong, need symbolic DWARF *)
+            match Elf.SymTable.of_addr_opt elf.symbols addr with
             | Some sym -> Some sym
             | None -> None
           )
diff --git a/src/dw/loc.ml b/src/dw/loc.ml
index 7b194e3e..bcd4eda0 100644
--- a/src/dw/loc.ml
+++ b/src/dw/loc.ml
@@ -120,7 +120,8 @@ let of_linksem ?(amap = Arch.dwarf_reg_map ()) (elf : Elf.File.t) : linksem_t ->
   (* Global *)
   | [{ op_semantics = OpSem_lit; op_code = code; op_argument_values = [arg]; _ }] as ops
     when Z.to_int code = vDW_OP_addr -> (
-      try Global (Elf.SymTable.of_addr_with_offset elf.symbols @@ int_of_oav arg)
+      let addr = Elf.Symbol.{ section = ".data"; offset = int_of_oav arg } in (* TODO this is wrong, need symbolic DWARF*)
+      try Global (Elf.SymTable.of_addr_with_offset elf.symbols @@ addr)
       with Not_found ->
         warn "Symbol at 0x%x not found in Loc.of_linksem" (int_of_oav arg);
         Dwarf ops
diff --git a/src/state/base.ml b/src/state/base.ml
index 52cad8a8..33d4de14 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -429,9 +429,10 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
       if not @@ ConcreteEval.is_concrete addr then None
       else
         let int_addr = ConcreteEval.eval addr |> Value.expect_bv |> BitVec.to_int in
+        let sym_addr = Elf.Symbol.{ section = ".rodata"; offset = int_addr } in (* TODO this is wrong *)
         let size = size |> Ast.Size.to_bits in
         try
-          let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols int_addr in
+          let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols sym_addr in
           if sym.writable then None
           else
             (* Assume little endian here *)

From 03ce63b6e1f1a5764d59712afe884c637b4d78fd Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 4 Jan 2025 20:16:54 +0100
Subject: [PATCH 005/116] DIsable typing

---
 src/trace/run.ml   | 14 ++++++++------
 src/trace/typer.ml |  4 ++--
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/trace/run.ml b/src/trace/run.ml
index bd8eb38d..986d3b53 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -70,10 +70,11 @@ let expand ~(ctxt : ctxt) (exp : Base.exp) : State.exp =
     otherwise the type will be [None] *)
 let expand_tval ~(ctxt : ctxt) (exp : Base.exp) : State.tval =
   let sexp = expand ~ctxt exp in
-  if Ctxt.typing_enabled ~ctxt then
+  (* if Ctxt.typing_enabled ~ctxt then
     let ctyp = Typer.expr ~ctxt exp in
     { ctyp; exp = sexp }
-  else { ctyp = None; exp = sexp }
+  else *)
+    { ctyp = None; exp = sexp }
 
 (** Run the event.
     The modified state is the one inside [ctxt]. *)
@@ -85,22 +86,23 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
   | ReadMem { addr; value; size } ->
       let naddr = expand ~ctxt addr in
       let tval =
-        match ctxt.dwarf with
+        (* match ctxt.dwarf with
         | Some dwarf ->
             let ptrtype = Typer.expr ~ctxt addr in
             Typer.read ~dwarf ctxt.state ?ptrtype ~addr:naddr ~size
-        | None -> State.read_noprov ctxt.state ~addr:naddr ~size |> State.Tval.of_exp
+        | None -> *)
+            State.read_noprov ctxt.state ~addr:naddr ~size |> State.Tval.of_exp
       in
       HashVector.set ctxt.mem_reads value tval
   | WriteMem { addr; value; size } -> (
       let naddr = expand ~ctxt addr in
-      match ctxt.dwarf with
+      (* match ctxt.dwarf with
       | Some dwarf ->
           let ptrtype = Typer.expr ~ctxt addr in
           debug "Typed write mem with ptr:%t" (Pp.top (Pp.opt Ctype.pp) ptrtype);
           let value = expand_tval ~ctxt value in
           Typer.write ~dwarf ctxt.state ?ptrtype ~addr:naddr ~size value
-      | None ->
+      | None -> *)
           let value = expand ~ctxt value in
           State.write_noprov ctxt.state ~addr:naddr ~size value
     )
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index e83f3284..f7b0f6de 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -1,4 +1,4 @@
-(*==================================================================================*)
+(* ==================================================================================
 (*  BSD 2-Clause License                                                            *)
 (*                                                                                  *)
 (*  Copyright (c) 2020-2021 Thibaut Pérami                                          *)
@@ -314,4 +314,4 @@ let write ~(dwarf : Dw.t) (s : State.t) ?(ptrtype : Ctype.t option) ~addr ~size
       State.write ~provenance s ~addr ~size value.exp
   | _ ->
       warn "Writing without provenance";
-      State.write_noprov s ~addr ~size value.exp
+      State.write_noprov s ~addr ~size value.exp *)

From 261484664121657870d1dfc17c0cd2e2cf7c66ce Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 5 Jan 2025 11:34:06 +0100
Subject: [PATCH 006/116] Refactor (symbolic) address to separate module

---
 src/dw/func.ml       |  2 +-
 src/dw/loc.ml        |  2 +-
 src/elf/address.ml   | 10 ++++++++++
 src/elf/symTable.ml  | 18 +++++++++---------
 src/elf/symTable.mli | 10 +++++-----
 src/elf/symbol.ml    | 15 +++------------
 src/elf/symbol.mli   | 11 +----------
 src/state/base.ml    |  2 +-
 8 files changed, 31 insertions(+), 39 deletions(-)
 create mode 100644 src/elf/address.ml

diff --git a/src/dw/func.ml b/src/dw/func.ml
index e8738d24..18fdd676 100644
--- a/src/dw/func.ml
+++ b/src/dw/func.ml
@@ -140,7 +140,7 @@ let of_linksem (elf : Elf.File.t) (tenv : Ctype.env) (lfun : linksem_t) =
     | None -> (
         match lfun.ss_entry_address with
         | Some a -> (
-            let addr = Elf.Symbol.{section = ".text"; offset = Nat_big_num.to_int a} in (* TODO this is wrong, need symbolic DWARF *)
+            let addr = Elf.Address.{section = ".text"; offset = Nat_big_num.to_int a} in (* TODO this is wrong, need symbolic DWARF *)
             match Elf.SymTable.of_addr_opt elf.symbols addr with
             | Some sym -> Some sym
             | None -> None
diff --git a/src/dw/loc.ml b/src/dw/loc.ml
index bcd4eda0..e9aacff2 100644
--- a/src/dw/loc.ml
+++ b/src/dw/loc.ml
@@ -120,7 +120,7 @@ let of_linksem ?(amap = Arch.dwarf_reg_map ()) (elf : Elf.File.t) : linksem_t ->
   (* Global *)
   | [{ op_semantics = OpSem_lit; op_code = code; op_argument_values = [arg]; _ }] as ops
     when Z.to_int code = vDW_OP_addr -> (
-      let addr = Elf.Symbol.{ section = ".data"; offset = int_of_oav arg } in (* TODO this is wrong, need symbolic DWARF*)
+      let addr = Elf.Address.{ section = ".data"; offset = int_of_oav arg } in (* TODO this is wrong, need symbolic DWARF*)
       try Global (Elf.SymTable.of_addr_with_offset elf.symbols @@ addr)
       with Not_found ->
         warn "Symbol at 0x%x not found in Loc.of_linksem" (int_of_oav arg);
diff --git a/src/elf/address.ml b/src/elf/address.ml
new file mode 100644
index 00000000..c9f3b66b
--- /dev/null
+++ b/src/elf/address.ml
@@ -0,0 +1,10 @@
+type t = {
+  section : string;
+  offset: int;
+}
+
+let pp addr = Pp.(!^(addr.section) ^^ !^"+" ^^ ptr addr.offset)
+
+let of_linksem (section, offset) = { section; offset = Z.to_int offset }
+
+let (+) addr offset = { section = addr.section; offset = addr.offset + offset }
\ No newline at end of file
diff --git a/src/elf/symTable.ml b/src/elf/symTable.ml
index dee03749..f0ac45a1 100644
--- a/src/elf/symTable.ml
+++ b/src/elf/symTable.ml
@@ -62,7 +62,7 @@ module SMap = Map.Make (String)
 module AddrMap = struct
   type t = RMap.t SMap.t
 
-  let add t addr sym =
+  let add t (addr: Address.t) sym =
     SMap.update addr.section (fun old ->
       let old = match old with
       | None -> RMap.empty
@@ -71,28 +71,28 @@ module AddrMap = struct
       Some (RMap.add old addr.offset sym)
     ) t
   
-  let update f t addr =
+  let update f t (addr: Address.t) =
     SMap.update addr.section (Option.map (fun x -> RMap.update f x addr.offset)) t
   
   let empty = SMap.empty
 
-  let at t addr =
+  let at t (addr: Address.t) =
     SMap.find addr.section t |> Fun.flip RMap.at addr.offset
 
-  let at_opt t addr =
+  let at_opt t (addr: Address.t) =
     Option.bind (SMap.find_opt addr.section t) @@ Fun.flip RMap.at_opt addr.offset
   
-  let at_off t addr =
+  let at_off t (addr: Address.t) =
     SMap.find addr.section t |> Fun.flip RMap.at_off addr.offset
   
-  let at_off_opt t addr =
+  let at_off_opt t (addr: Address.t) =
     Option.bind (SMap.find_opt addr.section t) @@ Fun.flip RMap.at_off_opt addr.offset
   
   let bindings t =
     let sections = SMap.bindings t in
     List.bind sections @@ fun (section, rmap) ->
       let inner_bindings = RMap.bindings rmap in
-      List.map (fun (offset, sym) -> ({section; offset}, sym)) inner_bindings
+      List.map (fun (offset, sym) -> (Address.{section; offset}, sym)) inner_bindings
   
   
 end
@@ -134,7 +134,7 @@ let of_addr_with_offset t addr = AddrMap.at_off t.by_addr addr
 
 let of_addr_with_offset_opt t addr = AddrMap.at_off_opt t.by_addr addr
 
-let to_addr_offset (sym, offset) = { section = sym.addr.section; offset = sym.addr.offset + offset }
+let to_addr_offset (sym, offset) = Address.(sym.addr + offset)
 
 let string_of_sym_offset ((sym, off) : sym_offset) = sym.name ^ "+" ^ string_of_int off
 
@@ -156,7 +156,7 @@ let of_linksem linksem_map =
   in
   List.fold_left add_linksem_sym_to_map empty linksem_map
 
-let pp_raw st = AddrMap.bindings st.by_addr |> List.map (Pair.map pp_addr pp_raw) |> Pp.mapping "syms"
+let pp_raw st = AddrMap.bindings st.by_addr |> List.map (Pair.map Address.pp pp_raw) |> Pp.mapping "syms"
 
 let iter t f = SMap.iter (fun _ value -> f value) t.by_name
 
diff --git a/src/elf/symTable.mli b/src/elf/symTable.mli
index 0b919a8a..18e7de50 100644
--- a/src/elf/symTable.mli
+++ b/src/elf/symTable.mli
@@ -78,19 +78,19 @@ val of_name_opt : t -> string -> sym option
 
 (** Get the symbol owning that address. Not_found is raised if no symbol own that address.data
       See {!of_addr_opt} *)
-val of_addr : t -> Symbol.addr -> sym
+val of_addr : t -> Address.t -> sym
 
 (** Get the symbol owning that address. None if no symbol own that address. See {!of_addr} *)
-val of_addr_opt : t -> Symbol.addr -> sym option
+val of_addr_opt : t -> Address.t -> sym option
 
 (** Get a symbol with the offset that correspond to that address *)
-val of_addr_with_offset : t -> Symbol.addr -> sym_offset
+val of_addr_with_offset : t -> Address.t -> sym_offset
 
 (** Get a symbol with the offset that correspond to that address *)
-val of_addr_with_offset_opt : t -> Symbol.addr -> sym_offset option
+val of_addr_with_offset_opt : t -> Address.t -> sym_offset option
 
 (** Get back the raw address from a symbol+offset value *)
-val to_addr_offset : sym_offset -> Symbol.addr
+val to_addr_offset : sym_offset -> Address.t
 
 (** Transform a symbol + offset into the corresponding string *)
 val string_of_sym_offset : sym_offset -> string
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index bcbd00ae..da1bf9e0 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -52,17 +52,11 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
-(* TODO: move somewhere to reuse *)
-type addr = {
-  section : string;
-  offset: int;
-}
-
 type t = {
   name : string;
   other_names : string list;
   typ : typ;
-  addr : addr;
+  addr : Address.t;
   (* addr : int; *)
   size : int;
   writable : bool;
@@ -104,8 +98,7 @@ let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.
 let of_linksem (name, (typ, size, addr, data, _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
-  let section, offset = addr in
-  let addr = { section; offset = Z.to_int offset } in
+  let addr = Address.of_linksem addr in
   (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
 
@@ -128,8 +121,6 @@ let pp_typ typ =
   | FILE -> "FILE"
   | UNKNOWN -> "UNKNOWN"
 
-let pp_addr addr = Pp.(!^(addr.section) ^^ !^"+" ^^ ptr addr.offset)
-
 let pp_raw sym =
   Pp.(
     !^"sym"
@@ -138,7 +129,7 @@ let pp_raw sym =
            ("name", !^(sym.name));
            ("other names", separate nbspace (List.map string sym.other_names));
            ("typ", pp_typ sym.typ);
-           ("addr", pp_addr sym.addr);
+           ("addr", Address.pp sym.addr);
            (* ("addr", ptr sym.addr); *)
            ("size", ptr sym.size);
            ("writable", bool sym.writable);
diff --git a/src/elf/symbol.mli b/src/elf/symbol.mli
index 5b5e9e6f..0e91fa11 100644
--- a/src/elf/symbol.mli
+++ b/src/elf/symbol.mli
@@ -55,19 +55,13 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
-(* TODO: move somewhere to reuse *)
-type addr = {
-  section : string;
-  offset: int;
-}
-
 (** The ELF symbol. This type guarantee the data exists contrary to linksem symbols
     (it may be all zeros though) *)
 type t = {
   name : string;
   other_names : string list;
   typ : typ;
-  addr : addr;
+  addr : Address.t;
   (* addr : int; *)
   size : int;
   writable : bool;
@@ -117,8 +111,5 @@ val compare : t -> t -> int
 (** Pretty prints a symbol type *)
 val pp_typ : typ -> Pp.document
 
-(** Pretty prints symbolic address *)
-val pp_addr : addr -> Pp.document
-
 (** Raw pretty printing of a symbol *)
 val pp_raw : t -> Pp.document
diff --git a/src/state/base.ml b/src/state/base.ml
index 33d4de14..353c6cfd 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -429,7 +429,7 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
       if not @@ ConcreteEval.is_concrete addr then None
       else
         let int_addr = ConcreteEval.eval addr |> Value.expect_bv |> BitVec.to_int in
-        let sym_addr = Elf.Symbol.{ section = ".rodata"; offset = int_addr } in (* TODO this is wrong *)
+        let sym_addr = Elf.Address.{ section = ".rodata"; offset = int_addr } in (* TODO this is wrong *)
         let size = size |> Ast.Size.to_bits in
         try
           let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols sym_addr in

From fd2c3ff4483f9c59b8e24fd61ce8ac25fe273769 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 5 Jan 2025 12:01:00 +0100
Subject: [PATCH 007/116] Symbolic runner (TODO parsing symbolic addresses from
 SMT)

---
 src/run/runner.ml | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/run/runner.ml b/src/run/runner.ml
index 864dba24..760670f9 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -75,9 +75,9 @@ type slot =
 type t = {
   elf : Elf.File.t;
   dwarf : Dw.t option;
-  instrs : (int, slot) Hashtbl.t;  (** Instruction cache *)
+  instrs : (Elf.Address.t, slot) Hashtbl.t;  (** Instruction cache *)
   pc : Reg.t;
-  funcs : int Vec.t;  (** Loaded functions by loading order *)
+  funcs : Elf.Address.t Vec.t;  (** Loaded functions by loading order *)
 }
 
 let of_elf ?dwarf elf =
@@ -100,36 +100,36 @@ let load_sym runner (sym : Elf.Symbol.t) =
     (fun code ->
       let (addr, instr_len) =
         let result = !addr and len = BytesSeq.length code in
-        addr := !addr + len;
+        addr := Elf.Address.(!addr + len);
         (result, len)
       in
       try
         let instr = Trace.Cache.get_instr code in
         if instr.traces = [] then begin
-          debug "Instruction at 0x%x in %s is loaded as special" addr sym.name;
+          debug "Instruction at %t in %s is loaded as special" (Pp.top Elf.Address.pp addr) sym.name;
           Hashtbl.add runner.instrs addr (Special instr_len)
         end
         else begin
-          debug "Instruction at 0x%x in %s is loaded as normal. Traces are:\n%t" addr sym.name
+          debug "Instruction at %t in %s is loaded as normal. Traces are:\n%t" (Pp.top Elf.Address.pp addr) sym.name
             Pp.(topi Trace.Instr.pp instr);
           Hashtbl.add runner.instrs addr (Normal instr)
         end
       with exn ->
-        warn "Could not convert isla trace of instruction at 0x%x in %s to Trace.t: %s\n%s" addr
+        warn "Could not convert isla trace of instruction at %t in %s to Trace.t: %s\n%s" (Pp.top Elf.Address.pp addr)
           runner.elf.filename (Printexc.to_string exn) (Printexc.get_backtrace ());
         Hashtbl.add runner.instrs addr (IslaFail instr_len))
     opcode_list
 
 (** Fetch an instruction, and return corresponding slot. *)
-let fetch (runner : t) (pc : int) : slot =
-  debug "Fetching PC 0x%x" pc;
+let fetch (runner : t) (pc : Elf.Address.t) : slot =
+  debug "Fetching PC %t" (Pp.top Elf.Address.pp pc);
   match Hashtbl.find_opt runner.instrs pc with
   | Some v -> v
   | None -> (
       match Elf.SymTable.of_addr_opt runner.elf.symbols pc with
       | Some sym when sym.typ = Elf.Symbol.FUNC ->
           if Hashtbl.mem runner.instrs sym.addr then begin
-            warn "Tried to fetch in middle of instructions in %s at 0x%x" runner.elf.filename pc;
+            warn "Tried to fetch in middle of instructions in %s at %t" runner.elf.filename (Pp.top Elf.Address.pp pc);
             Hashtbl.add runner.instrs pc Nocode;
             Nocode
           end
@@ -138,13 +138,13 @@ let fetch (runner : t) (pc : int) : slot =
             match Hashtbl.find_opt runner.instrs pc with
             | Some v -> v
             | None ->
-                warn "Tried to fetch in middle of instructions in %s at 0x%x" runner.elf.filename
-                  pc;
+                warn "Tried to fetch in middle of instructions in %s at %t" runner.elf.filename
+                  (Pp.top Elf.Address.pp pc);
                 Hashtbl.add runner.instrs pc Nocode;
                 Nocode
           end
       | _ ->
-          warn "Tried to fetch outside of normal code in %s at 0x%x" runner.elf.filename pc;
+          warn "Tried to fetch outside of normal code in %s at %t" runner.elf.filename (Pp.top Elf.Address.pp pc);
           Hashtbl.add runner.instrs pc Nocode;
           Nocode
     )
@@ -188,6 +188,7 @@ let skip runner state : State.t list =
   let pc_exp = State.get_reg_exp state runner.pc in
   try
     let pc = pc_exp |> Ast.expect_bits |> BitVec.to_int in
+    let pc = Elf.Address.{ section = ".text"; offset = pc } in (* TODO this is wrong, should get symbolic value from pc_exp *)
     match fetch runner pc with
     | Normal { traces = _; read = _; written = _; length; opcode = _ }
      |Special length
@@ -195,7 +196,7 @@ let skip runner state : State.t list =
         let state = State.copy_if_locked state in
         State.bump_pc ~pc:runner.pc state length;
         [state]
-    | Nocode -> Raise.fail "Trying to skip 0x%x in %s: no code there" pc runner.elf.filename
+    | Nocode -> Raise.fail "Trying to skip %t in %s: no code there" (Pp.tos Elf.Address.pp pc) runner.elf.filename
   with exn ->
     err "Trying to skip instruction at %t in %s: Unexpected error"
       Pp.(top State.Exp.pp pc_exp)
@@ -220,13 +221,14 @@ let run ?prelock runner state : State.t list =
   let pc_exp = State.get_reg_exp state runner.pc in
   try
     let pc = pc_exp |> Ast.expect_bits |> BitVec.to_int in
+    let pc = Elf.Address.{ section = ".text"; offset = pc } in (* TODO this is wrong, should get symbolic value from pc_exp *)
     match fetch runner pc with
     | Normal instr -> execute_normal ?prelock ~pc runner instr state
     | Special _ ->
-        Raise.fail "Special instruction at 0x%x in %s. unsupported for now" pc runner.elf.filename
-    | Nocode -> Raise.fail "Trying to run 0x%x in %s: no code there" pc runner.elf.filename
+        Raise.fail "Special instruction at %t in %s. unsupported for now" (Pp.tos Elf.Address.pp pc) runner.elf.filename
+    | Nocode -> Raise.fail "Trying to run %t in %s: no code there" (Pp.tos Elf.Address.pp pc) runner.elf.filename
     | IslaFail _ ->
-        Raise.fail "Trying to run 0x%x in %s: Isla pipeline failed on that instruction" pc
+        Raise.fail "Trying to run %t in %s: Isla pipeline failed on that instruction" (Pp.tos Elf.Address.pp pc)
           runner.elf.filename
   with exn ->
     err "Trying to run instruction at %t in %s: Unexpected error"
@@ -257,4 +259,4 @@ let pp_slot =
 (** Dump instruction table *)
 let pp_instr (runner : t) =
   let open Pp in
-  hashtbl_sorted ~name:"Instructions" ~compare ptr pp_slot runner.instrs
+  hashtbl_sorted ~name:"Instructions" ~compare Elf.Address.pp pp_slot runner.instrs

From d42ecf06eb6410fafa9d04ddff56a8e33c3ee9c5 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 5 Jan 2025 16:06:53 +0100
Subject: [PATCH 008/116] Run relocatable file

TODOS:
- translations from/to SMT
- relocations
- translations from DWARF
- provenance or concrete SP
- simplify read addresses
---
 src/bin/dune            |  4 ++--
 src/bin/main.ml         |  4 ++--
 src/bin/main_riscv64.ml |  4 ++--
 src/bin/readDwarf.ml    |  2 +-
 src/dune                |  2 ++
 src/run/block.ml        |  2 +-
 src/run/block_lib.ml    | 10 ++++++++--
 src/run/func.ml         |  2 +-
 src/run/funcRD.ml       | 12 ++++++------
 src/state/base.ml       | 13 +++++++++----
 src/state/base.mli      |  6 ++++--
 11 files changed, 38 insertions(+), 23 deletions(-)

diff --git a/src/bin/dune b/src/bin/dune
index f4c90590..fea23d27 100644
--- a/src/bin/dune
+++ b/src/bin/dune
@@ -4,7 +4,7 @@
  (modules main)
  (flags
   (:standard -open Utils))
- (libraries config run utils sig_aarch64 other_cmds branchTable))
+ (libraries config run utils sig_aarch64 other_cmds))
 
 (executable
  (name main_riscv64)
@@ -12,7 +12,7 @@
  (modules main_riscv64)
  (flags
   (:standard -open Utils))
- (libraries config run utils sig_riscv64 other_cmds branchTable))
+ (libraries config run utils sig_riscv64 other_cmds))
 
 (library
  (name other_cmds)
diff --git a/src/bin/main.ml b/src/bin/main.ml
index fc17e98a..714c0fc2 100644
--- a/src/bin/main.ml
+++ b/src/bin/main.ml
@@ -71,9 +71,9 @@ let commands =
     Run.Func.command;
     Run.Instr.command;
     Run.Block.command;
-    Run.FuncRD.command;
+    (* Run.FuncRD.command; *)
     Other_cmds.CopySourcesCmd.command;
-    BranchTable.command;
+    (* BranchTable.command; *)
   ]
 
 let _ = Printexc.record_backtrace Config.enable_backtrace
diff --git a/src/bin/main_riscv64.ml b/src/bin/main_riscv64.ml
index 92a20d0f..50622cb7 100644
--- a/src/bin/main_riscv64.ml
+++ b/src/bin/main_riscv64.ml
@@ -71,9 +71,9 @@ let commands =
     Run.Func.command;
     Run.Instr.command;
     Run.Block.command;
-    Run.FuncRD.command;
+    (* Run.FuncRD.command; *)
     Other_cmds.CopySourcesCmd.command;
-    BranchTable.command;
+    (* BranchTable.command; *)
   ]
 
 let _ = Printexc.record_backtrace Config.enable_backtrace
diff --git a/src/bin/readDwarf.ml b/src/bin/readDwarf.ml
index 16d38882..957552f8 100644
--- a/src/bin/readDwarf.ml
+++ b/src/bin/readDwarf.ml
@@ -71,7 +71,7 @@ let commands =
     Run.Func.command;
     Run.Instr.command;
     Run.Block.command;
-    Run.FuncRD.command;
+    (* Run.FuncRD.command; *)
     CopySourcesCmd.command;
   ]
 
diff --git a/src/dune b/src/dune
index cdaa4d1c..b474cb2a 100644
--- a/src/dune
+++ b/src/dune
@@ -2,3 +2,5 @@
  (release
   (flags
    (:standard -short-paths))))
+
+(dirs :standard \ branchTable)
\ No newline at end of file
diff --git a/src/run/block.ml b/src/run/block.ml
index 89d0c0e0..ed9f8ddb 100644
--- a/src/run/block.ml
+++ b/src/run/block.ml
@@ -109,7 +109,7 @@ let gen_block ((elf : Elf.File.t), (symoffset : Elf.SymTable.sym_offset)) len br
     let open Option in
     unlift_pair
     @@ let+ l = len in
-       (start, start + l)
+       (start, Elf.Address.(start + l))
   in
   let endpred = Block_lib.gen_endpred ?min ?max ~brks () in
   Trace.Cache.start @@ Arch.get_isla_config ();
diff --git a/src/run/block_lib.ml b/src/run/block_lib.ml
index 25e5c528..ddb6c14d 100644
--- a/src/run/block_lib.ml
+++ b/src/run/block_lib.ml
@@ -56,7 +56,7 @@ open Logs.Logger (struct
 end)
 
 (** [endpred pc_exp] gives when to stop *)
-type t = { runner : Runner.t; start : int; endpred : State.exp -> string option }
+type t = { runner : Runner.t; start : Elf.Address.t; endpred : State.exp -> string option }
 
 (** Build a complex block starting from [start] in [sym] and ending when [endpred] says so.
     [endpred] is a predicate on the symbolic PC expression *)
@@ -137,7 +137,7 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
     end
   in
   let state = State.copy start in
-  State.set_pc ~pc:pcreg state b.start;
+  State.set_pc_sym ~pc:pcreg state b.start;
   let rest = [run_from state] in
   State.Tree.{ state = start; data = Start; rest }
 
@@ -148,6 +148,12 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
     - pc has be seen more than [loop]
 *)
 let gen_endpred ?min ?max ?loop ?(brks = []) () : State.exp -> string option =
+  (* HACK *)
+  (* TODO rewrite for symbolic pc *)
+  let min = Option.map (fun min -> min.Elf.Address.offset) min in
+  let max = Option.map (fun max -> max.Elf.Address.offset) max in
+  let brks = List.map (fun brks -> brks.Elf.Address.offset) brks in
+  (*  *)
   let endnow fmt = Printf.ksprintf Option.some fmt in
   let pchtbl = Hashtbl.create 10 in
   let loop_str =
diff --git a/src/run/func.ml b/src/run/func.ml
index 3afdb1d5..d41d3c03 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -85,7 +85,7 @@ let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(br
         let open Option in
         unlift_pair
         @@ let+ l = len in
-           (sym.addr, sym.addr + l)
+           (sym.addr, Elf.Address.(sym.addr + l))
       in
       let endpred = Block_lib.gen_endpred ?min ?max ?loop ~brks () in
       let runner = Runner.of_dwarf dwarf in
diff --git a/src/run/funcRD.ml b/src/run/funcRD.ml
index 9e1dc449..374b7e9d 100644
--- a/src/run/funcRD.ml
+++ b/src/run/funcRD.ml
@@ -48,14 +48,14 @@
     instructions.*)
 
 open Cmdliner
-open Config.CommonOpt
-open Fun
+(* open Config.CommonOpt *)
+(* open Fun *)
 
 open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-let run_func_rd elfname name objdump_d branchtables breakpoints =
+(* let run_func_rd elfname name objdump_d branchtables breakpoints =
   base "Running with rd %s in %s" name elfname;
   base "Loading %s" elfname;
   let dwarf = Dw.of_file elfname in
@@ -142,7 +142,7 @@ let run_func_rd elfname name objdump_d branchtables breakpoints =
                  |> List.iter (fun (msg, st, regs) ->
                         base "At 0x%x, %s:\n%t" pc msg Pp.(topi (State.pp_partial ~regs) st));
                  print_string (print_analyse_instruction pc)))
-        runner.funcs
+        runner.funcs *)
 
 let elf =
   let doc = "ELF file from which to pull the code" in
@@ -168,7 +168,7 @@ let breakpoints =
   in
   Arg.(value & opt_all string [] & info ["b"; "break"] ~docv:"POSITION" ~doc)
 
-let term =
+(* let term =
   Term.(
     CmdlinerHelper.func_options comopts run_func_rd
     $ elf $ func $ objdump_d $ branch_table $ breakpoints)
@@ -181,4 +181,4 @@ let info =
   in
   Cmd.(info "run-func-rd" ~doc ~exits)
 
-let command = (term, info)
+let command = (term, info) *)
diff --git a/src/state/base.ml b/src/state/base.ml
index 353c6cfd..abd14f3f 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -317,7 +317,7 @@ type t = {
           However the symbolic execution should always be more concrete with
           it than without it *)
   fenv : Fragment.env;  (** The memory type environment. See {!Fragment.env} *)
-  mutable last_pc : int;
+  mutable last_pc : Elf.Address.t;
       (** The PC of the instruction that lead into this state. The state should be
           right after that instruction. This has no semantic meaning as part of the state.
           It's just for helping knowing what comes from where *)
@@ -354,7 +354,7 @@ let make ?elf () =
       mem = Mem.empty ();
       elf;
       fenv = Fragment.Env.make ();
-      last_pc = 0;
+      last_pc = Elf.Address.{ section = ".text"; offset = 0 }; (* TODO is this right? *)
     }
   in
   next_id := id + 1;
@@ -498,6 +498,11 @@ let set_pc ~(pc : Reg.t) (s : t) (pcval : int) =
   let ctyp = Ctype.of_frag Ctype.Global ~offset:pcval ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
 
+(* TODO *)
+let set_pc_sym ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
+  set_pc ~pc s pcval.offset
+  
+
 let bump_pc ~(pc : Reg.t) (s : t) (bump : int) =
   let pc_exp = get_reg_exp s pc in
   assert (ConcreteEval.is_concrete pc_exp);
@@ -520,7 +525,7 @@ let pp s =
     [
       ("id", Id.pp s.id);
       ("base_state", Option.fold ~none:!^"none" ~some:(fun s -> Id.pp s.id) s.base_state);
-      ("last_pc", ptr s.last_pc);
+      ("last_pc", Elf.Address.pp s.last_pc);
       ("regs", Reg.Map.pp Tval.pp s.regs);
       ("fenv", Fragment.Env.pp s.fenv);
       ("read_vars", Vec.ppi Tval.pp s.read_vars);
@@ -537,7 +542,7 @@ let pp_partial ~regs s =
        [
          ("id", Id.pp s.id |> some);
          ("base_state", Option.map (fun s -> Id.pp s.id) s.base_state);
-         ("last_pc", ptr s.last_pc |> some);
+         ("last_pc", Elf.Address.pp s.last_pc |> some);
          ( "regs",
            List.map (fun reg -> (Reg.pp reg, Reg.Map.get s.regs reg |> Tval.pp)) regs
            |> Pp.mapping "" |> some );
diff --git a/src/state/base.mli b/src/state/base.mli
index 455943b0..05669eb6 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -292,7 +292,7 @@ type t = private {
           However the symbolic execution should always be more concrete with
           it than without it *)
   fenv : Fragment.env;  (** The memory type environment. See {!Fragment.env} *)
-  mutable last_pc : int;
+  mutable last_pc : Elf.Address.t;
       (** The PC of the instruction that lead into this state. The state should be
           right after that instruction. This has no semantic meaning as part of the state.
           It's just for helping knowing what comes from where *)
@@ -464,6 +464,8 @@ val update_reg_exp : t -> Reg.t -> (exp -> exp) -> unit
 (** Set the PC to a concrete value and keep its type appropriate *)
 val set_pc : pc:Reg.t -> t -> int -> unit
 
+val set_pc_sym : pc:Reg.t -> t -> Elf.Address.t -> unit
+
 (** Bump a concrete PC by a concrete bump (generally the size of a non-branching instruction *)
 val bump_pc : pc:Reg.t -> t -> int -> unit
 
@@ -471,7 +473,7 @@ val bump_pc : pc:Reg.t -> t -> int -> unit
 val concretize_pc : pc:Reg.t -> t -> unit
 
 (** Set the [last_pc] of the state *)
-val set_last_pc : t -> int -> unit
+val set_last_pc : t -> Elf.Address.t -> unit
 
 (** {1 Pretty printing } *)
 

From fbd7c07712dea148d651e81787c333bdf7249dc4 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 6 Jan 2025 22:56:36 +0100
Subject: [PATCH 009/116] Enable typer

---
 src/arch/aarch64/sig.ml |  2 +-
 src/arch/riscv64/sig.ml |  2 +-
 src/ctype/ctype.ml      |  4 ++--
 src/state/base.ml       |  3 ++-
 src/trace/run.ml        | 17 ++++++++++-------
 src/trace/typer.ml      | 10 +++++-----
 6 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/arch/aarch64/sig.ml b/src/arch/aarch64/sig.ml
index 18b0b18c..af5bd091 100644
--- a/src/arch/aarch64/sig.ml
+++ b/src/arch/aarch64/sig.ml
@@ -331,7 +331,7 @@ let get_abi api =
     State.set_reg_type state sp
       (Ctype.of_frag ~provenance:stack_provenance @@ DynFragment stack_frag_id);
     State.set_reg state r30
-      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere Ctype.Global) RetAddr);
+      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global ".text")) RetAddr);
     let sp_exp = State.Exp.of_reg state.id sp in
     (* Assert that Sp is 16 bytes aligned *)
     State.push_assert state Exp.Typed.(extract ~last:3 ~first:0 sp_exp = bits_int ~size:4 0);
diff --git a/src/arch/riscv64/sig.ml b/src/arch/riscv64/sig.ml
index 0e14e523..c999179e 100644
--- a/src/arch/riscv64/sig.ml
+++ b/src/arch/riscv64/sig.ml
@@ -289,7 +289,7 @@ let get_abi api =
     State.set_reg_type state sp
       (Ctype.of_frag ~provenance:stack_provenance @@ DynFragment stack_frag_id);
     State.set_reg state ra
-      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere Ctype.Global) RetAddr);
+      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global ".text")) RetAddr);
     let sp_exp = State.Exp.of_reg state.id sp in
     (* Assert that Sp is 16 bytes aligned *)
     State.push_assert state Exp.Typed.(extract ~last:3 ~first:0 sp_exp = bits_int ~size:4 0);
diff --git a/src/ctype/ctype.ml b/src/ctype/ctype.ml
index daa31632..fab17f6b 100644
--- a/src/ctype/ctype.ml
+++ b/src/ctype/ctype.ml
@@ -136,7 +136,7 @@ and fragment =
   | Single of t  (** Single object: Only when accessing of a global variable *)
   | DynArray of t  (** Generic C pointer, may point to multiple element of that type *)
   | DynFragment of int  (** Writable fragment for memory whose type is changing dynamically *)
-  | Global
+  | Global of string
       (** The Global fragment that contains all the fixed ELF section
                .text, .data, .rodata, ... *)
 
@@ -669,7 +669,7 @@ and pp_fragment frag =
   | DynArray t -> pp t ^^ !^"[]"
   | Unknown -> !^"unknown"
   | DynFragment i -> dprintf "frag %d" i
-  | Global -> !^"global"
+  | Global s -> !^"global " ^^ !^s
 
 and pp_offset = function
   | Const off when off = 0 -> empty
diff --git a/src/state/base.ml b/src/state/base.ml
index abd14f3f..466a4ca0 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -493,9 +493,10 @@ let get_reg_exp s reg = get_reg s reg |> Tval.exp
 let update_reg_exp (s : t) (reg : Reg.t) (f : exp -> exp) =
   Reg.Map.get s.regs reg |> Tval.map_exp f |> Reg.Map.set s.regs reg
 
+(* TODO *)
 let set_pc ~(pc : Reg.t) (s : t) (pcval : int) =
   let exp = Typed.bits_int ~size:64 pcval in
-  let ctyp = Ctype.of_frag Ctype.Global ~offset:pcval ~constexpr:true in
+  let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
 
 (* TODO *)
diff --git a/src/trace/run.ml b/src/trace/run.ml
index 986d3b53..9b4f820a 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -70,10 +70,10 @@ let expand ~(ctxt : ctxt) (exp : Base.exp) : State.exp =
     otherwise the type will be [None] *)
 let expand_tval ~(ctxt : ctxt) (exp : Base.exp) : State.tval =
   let sexp = expand ~ctxt exp in
-  (* if Ctxt.typing_enabled ~ctxt then
+  if Ctxt.typing_enabled ~ctxt then
     let ctyp = Typer.expr ~ctxt exp in
     { ctyp; exp = sexp }
-  else *)
+  else
     { ctyp = None; exp = sexp }
 
 (** Run the event.
@@ -85,24 +85,27 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
   | WriteReg { reg; value } -> Vec.add_one ctxt.reg_writes (reg, expand_tval ~ctxt value)
   | ReadMem { addr; value; size } ->
       let naddr = expand ~ctxt addr in
+      let ptrtype = Typer.expr ~ctxt addr in
+      debug "ptrtype: %t" Pp.(top (optional Ctype.pp) ptrtype);
       let tval =
-        (* match ctxt.dwarf with
+        match ctxt.dwarf with
         | Some dwarf ->
-            let ptrtype = Typer.expr ~ctxt addr in
             Typer.read ~dwarf ctxt.state ?ptrtype ~addr:naddr ~size
-        | None -> *)
+        | None ->
             State.read_noprov ctxt.state ~addr:naddr ~size |> State.Tval.of_exp
       in
       HashVector.set ctxt.mem_reads value tval
   | WriteMem { addr; value; size } -> (
       let naddr = expand ~ctxt addr in
-      (* match ctxt.dwarf with
+      let ptrtype = Typer.expr ~ctxt addr in
+      debug "ptrtype: %t" Pp.(top (optional Ctype.pp) ptrtype);
+      match ctxt.dwarf with
       | Some dwarf ->
           let ptrtype = Typer.expr ~ctxt addr in
           debug "Typed write mem with ptr:%t" (Pp.top (Pp.opt Ctype.pp) ptrtype);
           let value = expand_tval ~ctxt value in
           Typer.write ~dwarf ctxt.state ?ptrtype ~addr:naddr ~size value
-      | None -> *)
+      | None ->
           let value = expand ~ctxt value in
           State.write_noprov ctxt.state ~addr:naddr ~size value
     )
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index f7b0f6de..cf04c5af 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -1,4 +1,4 @@
-(* ==================================================================================
+(* ================================================================================== *)
 (*  BSD 2-Clause License                                                            *)
 (*                                                                                  *)
 (*  Copyright (c) 2020-2021 Thibaut Pérami                                          *)
@@ -178,7 +178,7 @@ let manyop ~ctxt (m : Ast.manyop) (tvals : tval list) : Ctype.t option =
       match List.hd tvals with
       | {
        exp = Unop (Extract (_, _), _, _);
-       ctyp = Some ({ unqualified = Ptr { fragment = Global; offset; _ }; _ } as ctyp);
+       ctyp = Some ({ unqualified = Ptr { fragment = Global _; offset; _ }; _ } as ctyp);
       } -> (
           match offset with
           | Somewhere -> Some ctyp
@@ -254,8 +254,8 @@ let fragment_at ~(dwarf : Dw.t) ~fenv ~size (frag : Ctype.fragment) at : Ctype.t
       let frag = Fragment.Env.get fenv i in
       let* (typ, off) = Fragment.at_off_opt frag at in
       Ctype.type_at ~env ~size typ off
-  | Global -> (
-      match Elf.SymTable.of_addr_with_offset_opt dwarf.elf.symbols at with
+  | Global s -> (
+      match Elf.SymTable.of_addr_with_offset_opt dwarf.elf.symbols Elf.Address.{ section = s; offset = at } with
       | Some (sym, offset) -> (
           match Hashtbl.find_opt dwarf.vars sym.name with
           | Some v -> Ctype.type_at ~env ~size v.ctype offset
@@ -314,4 +314,4 @@ let write ~(dwarf : Dw.t) (s : State.t) ?(ptrtype : Ctype.t option) ~addr ~size
       State.write ~provenance s ~addr ~size value.exp
   | _ ->
       warn "Writing without provenance";
-      State.write_noprov s ~addr ~size value.exp *)
+      State.write_noprov s ~addr ~size value.exp

From 49ffe70846bfb4f421bae33839e86df701aec510 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 7 Jan 2025 12:17:45 +0100
Subject: [PATCH 010/116] Some debug prints

---
 src/trace/run.ml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/trace/run.ml b/src/trace/run.ml
index 9b4f820a..f6eaf1c1 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -85,6 +85,7 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
   | WriteReg { reg; value } -> Vec.add_one ctxt.reg_writes (reg, expand_tval ~ctxt value)
   | ReadMem { addr; value; size } ->
       let naddr = expand ~ctxt addr in
+      debug "naddr: %t" (Pp.top State.Exp.pp naddr);
       let ptrtype = Typer.expr ~ctxt addr in
       debug "ptrtype: %t" Pp.(top (optional Ctype.pp) ptrtype);
       let tval =
@@ -97,6 +98,7 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
       HashVector.set ctxt.mem_reads value tval
   | WriteMem { addr; value; size } -> (
       let naddr = expand ~ctxt addr in
+      debug "naddr: %t" (Pp.top State.Exp.pp naddr);
       let ptrtype = Typer.expr ~ctxt addr in
       debug "ptrtype: %t" Pp.(top (optional Ctype.pp) ptrtype);
       match ctxt.dwarf with

From 3f0498b721f3b52484981f27471678d6908cd543 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 7 Jan 2025 12:18:13 +0100
Subject: [PATCH 011/116] Mark potential bug

---
 src/trace/context.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/trace/context.ml b/src/trace/context.ml
index cd8b46be..bfbce294 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -67,7 +67,7 @@ let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
   assert (Base.Var.ty v = a);
   match v with
   | Register reg -> State.get_reg_exp ctxt.state reg
-  | NonDet (i, _) | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp
+  | NonDet (i, _) | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
 
 let map_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.var =
   assert (Base.Var.ty v = a);

From e4485cdf2153781052343b85cac0f7c19a9537df Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 7 Jan 2025 12:21:48 +0100
Subject: [PATCH 012/116] Add TODO

---
 src/arch/aarch64/sig.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/arch/aarch64/sig.ml b/src/arch/aarch64/sig.ml
index af5bd091..151fce0b 100644
--- a/src/arch/aarch64/sig.ml
+++ b/src/arch/aarch64/sig.ml
@@ -331,7 +331,7 @@ let get_abi api =
     State.set_reg_type state sp
       (Ctype.of_frag ~provenance:stack_provenance @@ DynFragment stack_frag_id);
     State.set_reg state r30
-      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global ".text")) RetAddr);
+      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global ".text")) RetAddr); (* TODO doesn't have to be .text *)
     let sp_exp = State.Exp.of_reg state.id sp in
     (* Assert that Sp is 16 bytes aligned *)
     State.push_assert state Exp.Typed.(extract ~last:3 ~first:0 sp_exp = bits_int ~size:4 0);

From 4ef12a190f742efde18cadf01fd363cbf8caf8b4 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 7 Jan 2025 18:55:41 +0100
Subject: [PATCH 013/116] Implement opcodes with relocations

---
 src/isla/cache.ml  | 35 ++++++++++++++++++++---------------
 src/isla/server.ml |  7 +++++++
 src/run/bb_lib.ml  |  2 +-
 src/run/instr.ml   |  2 +-
 src/run/runner.ml  |  2 +-
 src/trace/cache.ml |  4 ++--
 src/trace/instr.ml |  5 +++--
 7 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index 038bbdd6..f7d5850f 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -77,45 +77,49 @@ type config = Server.config
       bit 0 to back -1 : The start of the data
       bit back -1: set *)
 module Opcode (*: Cache.Key *) = struct
-  type t = BytesSeq.t option
+  type t = Server.opcode option
 
   let equal a b =
     match (a, b) with
     | (None, None) -> true
-    | (Some bs, Some bs2) -> BytesSeq.equal bs bs2
+    | (Some (bs, r1), Some (bs2, r2)) -> BytesSeq.equal bs bs2 && r1 = r2
     | _ -> false
 
+  let small_enough bs rel_id =
+    BytesSeq.length bs < BytesSeq.int_bytes && rel_id < 16
+
   let hash = function
     | None -> 0
-    | Some bs ->
+    | Some (bs, rel) ->
         let i = BytesSeq.getintle_ze bs 0 in
         let l = BytesSeq.length bs in
-        if l < BytesSeq.int_bytes then begin
+        let rel_id = Server.reloc_id rel in
+        if small_enough bs rel_id then begin
           assert (not @@ IntBits.get i IntBits.back);
           let res = IntBits.blit l 0 i (IntBits.back - 3) 3 in
+          let res = IntBits.blit rel_id 0 res (IntBits.back - 7) 4 in
           res
         end
         else IntBits.set i IntBits.back
 
-  let to_file file = function
+  let to_file _file = function
     | None -> ()
-    | Some bs ->
-        if BytesSeq.length bs < BytesSeq.int_bytes then ()
+    | Some (bs, rel) ->
+        let rel_id = Server.reloc_id rel in
+        if small_enough bs rel_id then ()
         else
-          let keyfile = Utils.Cache.to_keyfile file in
-          Files.write_bin BytesSeq.output keyfile bs
+          Raise.todo()
 
-  let of_file hash file =
+  let of_file hash _file =
     if hash = 0 then None
     else if IntBits.get hash IntBits.back then
-      let keyfile = Utils.Cache.to_keyfile file in
-      Some (Files.read BytesSeq.input keyfile)
+      Raise.todo()
     else
       let data = IntBits.sub hash 0 (IntBits.back - 3) in
       let size = IntBits.sub hash (IntBits.back - 3) 3 in
       let b = Bytes.create size in
       Bits.unsafe_blit_of_int data 0 b 0 (size * 8);
-      Some (BytesSeq.of_bytes b)
+      Some (BytesSeq.of_bytes b, None)
 end
 
 (** Representation of trace lists on disk.
@@ -216,13 +220,14 @@ let get_cache () =
   match !cache with Some cache -> cache | None -> failwith "Isla cache was not started"
 
 (** Get the traces of the opcode given. Use {!Server} if the value is not in the cache *)
-let get_traces (opcode : BytesSeq.t) : Base.rtrc list =
+let get_traces (opcode : Server.opcode) : Base.rtrc list =
   let (cache, config) = get_cache () in
   match IC.get_opt cache (Some opcode) with
   | Some trcs -> trcs
   | None ->
       ensure_started ();
-      let trcs = Server.request_bin_parsed opcode in
+      let raw_opcode, _ = opcode in (*TODO*)
+      let trcs = Server.request_bin_parsed raw_opcode in
       let ptrcs = Preprocess.preprocess config trcs in
       IC.add cache (Some opcode) ptrcs;
       ptrcs
diff --git a/src/isla/server.ml b/src/isla/server.ml
index 0fff247d..ec544bb7 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -68,6 +68,13 @@ type config = Config.t
     processor exception/fault) or not *)
 type trcs = (bool * Base.rtrc) list
 
+type reloc = |
+
+let reloc_id: reloc option -> int = function
+| None -> 0
+
+type opcode = BytesSeq.t * reloc option
+
 (** Bump when updating isla.
     TODO: move the version checking to allow a range of version.
     Also, right now the cache invalidation is based on
diff --git a/src/run/bb_lib.ml b/src/run/bb_lib.ml
index 083d07eb..477a9d98 100644
--- a/src/run/bb_lib.ml
+++ b/src/run/bb_lib.ml
@@ -80,7 +80,7 @@ let from_binary (code : BytesSeq.t) : t =
             "BB.from_binary: Multiple path instruction.\n\
              If this is not a branching instruction, try `run-block --linear'."
     in
-    code |> Isla.Cache.get_traces |> get_normal
+    (code, None) |> Isla.Cache.get_traces |> get_normal (*TODO relocs *)
   in
   let main = code |> BytesSeq.to_listbs ~len:4 |> List.map process |> Array.of_list in
   { main }
diff --git a/src/run/instr.ml b/src/run/instr.ml
index 07a8dab8..4b8ea439 100644
--- a/src/run/instr.ml
+++ b/src/run/instr.ml
@@ -152,7 +152,7 @@ let get_traces instr isla_run dump_types : traces =
   Isla.Cache.start @@ Arch.get_isla_config ();
   (* I call Init.init manually to print the register types *)
   Init.init () |> ignore;
-  let rtraces = Isla.Cache.get_traces instr in
+  let rtraces = Isla.Cache.get_traces (instr, None) in (* TODO relocs *)
   List.iter (fun t -> Isla.Type.type_trc t |> ignore) rtraces;
   if dump_types then base "Register types:\n%t\n" (Pp.topi State.Reg.pp_index ());
   if isla_run then IslaTraces rtraces else Traces (List.map Trace.of_isla rtraces)
diff --git a/src/run/runner.ml b/src/run/runner.ml
index 760670f9..ed65e3e2 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -104,7 +104,7 @@ let load_sym runner (sym : Elf.Symbol.t) =
         (result, len)
       in
       try
-        let instr = Trace.Cache.get_instr code in
+        let instr = Trace.Cache.get_instr (code, None) in (*TODO relocs*)
         if instr.traces = [] then begin
           debug "Instruction at %t in %s is loaded as special" (Pp.top Elf.Address.pp addr) sym.name;
           Hashtbl.add runner.instrs addr (Special instr_len)
diff --git a/src/trace/cache.ml b/src/trace/cache.ml
index 366f7bea..0f7d7e33 100644
--- a/src/trace/cache.ml
+++ b/src/trace/cache.ml
@@ -155,7 +155,7 @@ let get_cache () =
   match !cache with Some cache -> cache | None -> failwith "Trace cache was not started"
 
 (** Get the traces of the opcode given. Use {!Isla.Server} if the value is not in the cache *)
-let get_traces (opcode : BytesSeq.t) : Base.t list =
+let get_traces (opcode : Isla.Server.opcode) : Base.t list =
   let cache = get_cache () in
   match TC.get_opt cache (Some opcode) with
   | Some trcs -> trcs
@@ -168,4 +168,4 @@ let get_traces (opcode : BytesSeq.t) : Base.t list =
 
 (** Get a full blown {!Instr} from the opcode, going through the whole Isla pipeline
     if necessary.*)
-let get_instr (opcode : BytesSeq.t) : Instr.t = Instr.of_traces opcode @@ get_traces opcode
+let get_instr (opcode : Isla.Server.opcode) : Instr.t = Instr.of_traces opcode @@ get_traces opcode
diff --git a/src/trace/instr.ml b/src/trace/instr.ml
index 3dd01196..4f0b54b9 100644
--- a/src/trace/instr.ml
+++ b/src/trace/instr.ml
@@ -66,7 +66,7 @@ type t = {
   length : int;  (** Bytes length *)
   read : Reg.t list;
   written : Reg.t list;
-  opcode : BytesSeq.t;
+  opcode : Isla.Server.opcode;
 }
 
 let dedup_regs = List.sort_uniq State.Reg.compare
@@ -101,7 +101,8 @@ let trace_meta_of_trace trace =
 (** Generate full instruction data from a list of traces *)
 let of_traces opcode traces =
   let traces = List.map trace_meta_of_trace traces in
-  let length = BytesSeq.length opcode in
+  let raw_opcode, _ = opcode in
+  let length = BytesSeq.length raw_opcode in
   let read = dedup_regs @@ List.concat_map (fun (tr : trace_meta) -> tr.read) traces in
   let written = dedup_regs @@ List.concat_map (fun (tr : trace_meta) -> tr.written) traces in
   { traces; length; read; written; opcode }

From 8dd5040da133f682fed0f3f72fd7787e856ec82f Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 7 Jan 2025 23:58:58 +0100
Subject: [PATCH 014/116] [WIP] read relocations from linksem

---
 notes-TODO                    |  4 +++-
 src/elf/linksemRelocatable.ml | 45 +++++++++++++++++++++++++----------
 src/elf/relocations.ml        | 32 +++++++++++++++++++++++++
 src/elf/symbol.ml             | 17 +++++++++----
 src/elf/symbol.mli            |  9 +++++--
 5 files changed, 88 insertions(+), 19 deletions(-)
 create mode 100644 src/elf/relocations.ml

diff --git a/notes-TODO b/notes-TODO
index c8e943ae..66ca908d 100644
--- a/notes-TODO
+++ b/notes-TODO
@@ -1,3 +1,5 @@
 Symbolic symbol table
 - value of symbol?? (we don't have segments in relocatable files)
-- can probably keep the same api, but addresses are symbolic
\ No newline at end of file
+- can probably keep the same api, but addresses are symbolic
+
+Instruction fetch: is it sound? (rewriting .text)
\ No newline at end of file
diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
index 82b4e035..2123d8f3 100644
--- a/src/elf/linksemRelocatable.ml
+++ b/src/elf/linksemRelocatable.ml
@@ -1,18 +1,40 @@
 (* TODO header *)
 
+module SMap = Map.Make (String)
+
 type sym_addr = string * Z.t
 
-(* Like in linksem, but address is section+offset, and with a writable flag *)
-type symbol = string * (Z.t * Z.t * sym_addr * Byte_sequence_wrapper.byte_sequence * Z.t) * bool
+type rels =
+  | AArch64 of (Z.t, Abi_aarch64_symbolic_relocation.aarch64_relocation_target Elf_symbolic.abstract_relocation) Pmap.map
+
+type sym_data =
+Byte_sequence_wrapper.byte_sequence * rels
+
+
+(* Like in linksem, but address is section+offset, data has relocations and with a writable flag *)
+type symbol = string * (Z.t * Z.t * sym_addr * sym_data * Z.t) * bool
 
 type global_symbol_init_info = symbol list
 
 open Elf_symbol_table
 open Elf_interpreted_section
 
-let get_elf64_file_global_symbol_init f : global_symbol_init_info Error.error =
-  let secs = f.Elf_file.elf64_file_interpreted_sections in
-  Error.bind (Elf_file.get_elf64_file_symbol_table f) (fun (symtab, strtab) ->
+let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_init_info Error.error =
+  let secs = f.elf64_file_interpreted_sections in
+  let machine = f.elf64_file_header.elf64_machine in
+  Error.bind (Elf_file.get_elf64_file_symbol_table f) @@ fun (symtab, strtab) ->
+    let rel_cache = ref SMap.empty in
+    let get_relocs section =
+      match SMap.find_opt section !rel_cache with
+      | Some rels -> rels
+      | None ->
+        if machine = Elf_header.elf_ma_aarch64 then
+          Error.bind
+            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.abi_aarch64_relocation_to_abstract section)
+            @@ fun relocs -> Error.return (AArch64 relocs)
+        else
+          Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
+    in
     List.filter_map (
       fun entry ->
         let name = Uint32_wrapper.to_bigint entry.elf64_st_name in
@@ -29,11 +51,10 @@ let get_elf64_file_global_symbol_init f : global_symbol_init_info Error.error =
             else
               Byte_sequence.offset_and_cut addr_offset size section.elf64_section_body
             in
-            Error.bind data (fun data ->
-            Error.bind (String_table.get_string_at name strtab) (fun str ->
-              let write = Elf_file.flag_is_set Elf_section_header_table.shf_write section.elf64_section_flags in
-              Error.return (str, (typ, size, addr, data, bnd), write)
-            ))
+            Error.bind (get_relocs section.elf64_section_name_as_string) @@ fun relocs ->
+            Error.bind data @@ fun data ->
+              Error.bind (String_table.get_string_at name strtab) @@ fun str ->
+                let write = Elf_file.flag_is_set Elf_section_header_table.shf_write section.elf64_section_flags in
+              Error.return (str, (typ, size, addr, (data, relocs), bnd), write)
         ) (List.nth_opt secs shndx)
-    ) symtab |> Error.mapM Fun.id
-  )
\ No newline at end of file
+    ) symtab |> Error.mapM Fun.id
\ No newline at end of file
diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
new file mode 100644
index 00000000..e48871b7
--- /dev/null
+++ b/src/elf/relocations.ml
@@ -0,0 +1,32 @@
+module IMap = Map.Make (Int)
+
+type target =
+  AArch64 of Abi_aarch64_symbolic_relocation.aarch64_relocation_target
+
+type rel = {
+  target : target;
+  value : Elf_symbolic.symbolic_expression;
+}
+
+type t = rel IMap.t
+
+type linksem_t = LinksemRelocatable.rels
+
+let of_linksem: linksem_t -> t = function
+| LinksemRelocatable.AArch64 relocs ->
+    let add k Elf_symbolic.{ arel_value; arel_target } m =
+      IMap.add (Z.to_int k) { value = arel_value; target = AArch64 arel_target } m
+    in
+    Pmap.fold add relocs IMap.empty
+
+let sub rels off len =
+  rels
+  |> IMap.to_list
+  |> List.filter_map (fun (pos, rel) -> if off <= pos && pos < off + len then Some (pos-off, rel) else None)
+  |> IMap.of_list
+
+let pp rels =
+  if IMap.is_empty rels then
+    Pp.empty
+  else
+    Pp.string "(has relocations)"
\ No newline at end of file
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index da1bf9e0..8bdce76a 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -52,6 +52,11 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
+type data = {
+  data: BytesSeq.t;
+  relocations: Relocations.t
+}
+
 type t = {
   name : string;
   other_names : string list;
@@ -60,7 +65,7 @@ type t = {
   (* addr : int; *)
   size : int;
   writable : bool;
-  data : BytesSeq.t;
+  data : data;
 }
 
 type linksem_t = LinksemRelocatable.symbol
@@ -95,10 +100,11 @@ let _ =
 (* module SMap = Map.Make (String)
 let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000 *)
 
-let of_linksem (name, (typ, size, addr, data, _), writable) =
+let of_linksem (name, (typ, size, addr, (data, rels), _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
   let addr = Address.of_linksem addr in
+  let data = { data; relocations = Relocations.of_linksem rels } in
   (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
 
@@ -106,7 +112,10 @@ let is_interesting = function OBJECT | FUNC -> true | _ -> false
 
 let is_interesting_linksem lsym = lsym |> linksem_typ |> typ_of_linksem |> is_interesting
 
-let sub sym off len = BytesSeq.sub sym.data off len
+let sub sym off len = {
+  data = BytesSeq.sub sym.data.data off len;
+  relocations = Relocations.sub sym.data.relocations off len;
+}
 
 let compare s1 s2 = compare s1.addr s2.addr
 
@@ -133,5 +142,5 @@ let pp_raw sym =
            (* ("addr", ptr sym.addr); *)
            ("size", ptr sym.size);
            ("writable", bool sym.writable);
-           ("data", BytesSeq.ppby ~by:4 sym.data);
+           ("data", BytesSeq.ppby ~by:4 sym.data.data ^^ Relocations.pp sym.data.relocations);
          ])
diff --git a/src/elf/symbol.mli b/src/elf/symbol.mli
index 0e91fa11..3bc5803f 100644
--- a/src/elf/symbol.mli
+++ b/src/elf/symbol.mli
@@ -55,6 +55,11 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
+type data = {
+  data: BytesSeq.t;
+  relocations: Relocations.t
+}
+
 (** The ELF symbol. This type guarantee the data exists contrary to linksem symbols
     (it may be all zeros though) *)
 type t = {
@@ -65,7 +70,7 @@ type t = {
   (* addr : int; *)
   size : int;
   writable : bool;
-  data : BytesSeq.t;
+  data : data;
 }
 
 (** The type of an ELF symbol in linksem. See {!of_linksem}*)
@@ -103,7 +108,7 @@ val is_interesting : typ -> bool
 val is_interesting_linksem : linksem_t -> bool
 
 (** Take the BytesSeq.t corresponding to the offset and length *)
-val sub : t -> int -> int -> BytesSeq.t
+val sub : t -> int -> int -> data
 
 (** Starting address comparison *)
 val compare : t -> t -> int

From d11e65a696879db0234dc1440c39a7f1ceee4f72 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 8 Jan 2025 11:55:57 +0100
Subject: [PATCH 015/116] [WIP] relocations from linksem

---
 src/isla/server.ml | 8 +++++++-
 src/isla/test.ml   | 2 +-
 src/run/BB.ml      | 2 +-
 src/run/instr.ml   | 2 +-
 src/run/runner.ml  | 2 +-
 src/state/base.ml  | 2 +-
 6 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/isla/server.ml b/src/isla/server.ml
index ec544bb7..6c093fe3 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -68,10 +68,16 @@ type config = Config.t
     processor exception/fault) or not *)
 type trcs = (bool * Base.rtrc) list
 
-type reloc = |
+type reloc = Elf.Relocations.target
 
 let reloc_id: reloc option -> int = function
 | None -> 0
+| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640) -> 1
+| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320) -> 2
+| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP) -> 3
+| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD) -> 4
+| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST) -> 5
+| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 6
 
 type opcode = BytesSeq.t * reloc option
 
diff --git a/src/isla/test.ml b/src/isla/test.ml
index 29b011de..c44343d6 100644
--- a/src/isla/test.ml
+++ b/src/isla/test.ml
@@ -166,7 +166,7 @@ let input imode (arg : string) : (string * string) Term.ret =
         try Elf.SymTable.of_position_string elf.symbols s
         with Not_found -> fail "The position %s could not be found in %s" s arg
       in
-      `Ok (filename, BytesSeq.to_string (BytesSeq.sub sym.data off 4))
+      `Ok (filename, BytesSeq.to_string (BytesSeq.sub sym.data.data off 4)) (* TODO relocations *)
 
 let input_term = Term.(ret (const input $ imode_term $ arg))
 
diff --git a/src/run/BB.ml b/src/run/BB.ml
index 0e3cab82..cdddee56 100644
--- a/src/run/BB.ml
+++ b/src/run/BB.ml
@@ -101,7 +101,7 @@ let get_code elfname symname len : BytesSeq.t =
     with Not_found -> fail "The symbol %s cannot found in %s" symname elfname
   in
   let len = match len with Some i -> i | None -> sym.size - off in
-  Elf.Symbol.sub sym off len
+  (Elf.Symbol.sub sym off len).data (*TODO relocations*)
 
 let code_term = Term.(CmdlinerHelper.func_options comopts get_code $ elf $ sym $ len)
 
diff --git a/src/run/instr.ml b/src/run/instr.ml
index 4b8ea439..efa790bc 100644
--- a/src/run/instr.ml
+++ b/src/run/instr.ml
@@ -140,7 +140,7 @@ let get_instr arch instr elfopt : BytesSeq.t =
   in
   debug "Got symbol:\n%t\n" (Pp.topi Elf.Symbol.pp_raw sym);
   let len = 4 (* TODO proper Instruction length system *) in
-  BytesSeq.sub sym.data off len
+  BytesSeq.sub sym.data.data off len (*TODO relocations*)
 
 let instr_term = Term.(CmdlinerHelper.func_options comopts get_instr $ arch $ instr $ elf)
 
diff --git a/src/run/runner.ml b/src/run/runner.ml
index ed65e3e2..74eabce5 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -94,7 +94,7 @@ let of_dwarf dwarf = of_elf ~dwarf dwarf.elf
 let load_sym runner (sym : Elf.Symbol.t) =
   info "Loading symbol %s in %s" sym.name runner.elf.filename;
   Vec.add_one runner.funcs sym.addr;
-  let opcode_list = Arch.split_into_instrs sym.data in
+  let opcode_list = Arch.split_into_instrs sym.data.data in (* TODO relocations *)
   let addr = ref sym.addr in
   List.iter
     (fun code ->
diff --git a/src/state/base.ml b/src/state/base.ml
index 466a4ca0..4cda529c 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -436,7 +436,7 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
           if sym.writable then None
           else
             (* Assume little endian here *)
-            let bv = BytesSeq.getbvle ~size sym.data offset in
+            let bv = BytesSeq.getbvle ~size sym.data.data offset in (* TODO relocations *)
             Some (Typed.bits bv)
         with Not_found ->
           let rodata = elf.rodata in

From 8d1db3ee5e3bf77c726e5be0c70b4da24d2c38ce Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 8 Jan 2025 12:56:34 +0100
Subject: [PATCH 016/116] WIP instructions with relocations

---
 src/arch/aarch64/sig.ml | 13 ++++++++++++-
 src/arch/riscv64/sig.ml | 13 ++++++++++++-
 src/arch/sig.mli        |  2 +-
 src/run/runner.ml       |  5 +++--
 4 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/src/arch/aarch64/sig.ml b/src/arch/aarch64/sig.ml
index 151fce0b..658dab20 100644
--- a/src/arch/aarch64/sig.ml
+++ b/src/arch/aarch64/sig.ml
@@ -360,7 +360,18 @@ let assemble_to_elf instr =
   Sys.remove obj_file;
   elf_file
 
-let split_into_instrs = BytesSeq.to_listbs ~len:4
+let split_into_instrs (data: Elf.Symbol.data) = 
+  let module IMap = Elf.Relocations.IMap in
+  let rawdata = BytesSeq.to_listbs ~len:4 data.data in
+  List.mapi (fun pos bytes -> 
+      let (_, rel, rest) = IMap.split pos data.relocations in
+      if Option.is_some @@ IMap.find_first_opt (fun i -> i < pos + 4) rest then
+        Raise.fail "Misaligned relocation";      
+      Elf.Symbol.{
+        data = bytes;
+        relocations = rel |> Option.map (IMap.singleton 0) |> Option.value ~default:IMap.empty;
+      }
+    ) rawdata
 
 (** https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/RET--Return-from-subroutine- *)
 let is_ret code =
diff --git a/src/arch/riscv64/sig.ml b/src/arch/riscv64/sig.ml
index c999179e..4f661598 100644
--- a/src/arch/riscv64/sig.ml
+++ b/src/arch/riscv64/sig.ml
@@ -317,7 +317,18 @@ let assemble_to_elf instr =
   Sys.remove obj_file;
   elf_file
 
-let split_into_instrs = BytesSeq.to_listbs ~len:4
+let split_into_instrs (data: Elf.Symbol.data) = 
+  let module IMap = Elf.Relocations.IMap in
+  let rawdata = BytesSeq.to_listbs ~len:4 data.data in
+  List.mapi (fun pos bytes -> 
+      let (_, rel, rest) = IMap.split pos data.relocations in
+      if Option.is_some @@ IMap.find_first_opt (fun i -> i < pos + 4) rest then
+        Raise.fail "Misaligned relocation";      
+      Elf.Symbol.{
+        data = bytes;
+        relocations = rel |> Option.map (IMap.singleton 0) |> Option.value ~default:IMap.empty;
+      }
+    ) rawdata
 
 let is_ret code =
   assert (BytesSeq.length code = 4);
diff --git a/src/arch/sig.mli b/src/arch/sig.mli
index 13268696..a355e3e6 100644
--- a/src/arch/sig.mli
+++ b/src/arch/sig.mli
@@ -109,7 +109,7 @@ val sp : unit -> State.Reg.t
 val assemble_to_elf : string -> string
 
 (**  Split a byte-sequence into a list of instructions. *)
-val split_into_instrs : BytesSeq.t -> BytesSeq.t list
+val split_into_instrs : Elf.Symbol.data -> Elf.Symbol.data list
 
 (** Tell if an instruction is a return instruction. *)
 val is_ret : BytesSeq.t -> bool
diff --git a/src/run/runner.ml b/src/run/runner.ml
index 74eabce5..c3a4e031 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -94,16 +94,17 @@ let of_dwarf dwarf = of_elf ~dwarf dwarf.elf
 let load_sym runner (sym : Elf.Symbol.t) =
   info "Loading symbol %s in %s" sym.name runner.elf.filename;
   Vec.add_one runner.funcs sym.addr;
-  let opcode_list = Arch.split_into_instrs sym.data.data in (* TODO relocations *)
+  let opcode_list = Arch.split_into_instrs sym.data in (* TODO relocations *)
   let addr = ref sym.addr in
   List.iter
-    (fun code ->
+    (fun Elf.Symbol.{ data = code; relocations } ->
       let (addr, instr_len) =
         let result = !addr and len = BytesSeq.length code in
         addr := Elf.Address.(!addr + len);
         (result, len)
       in
       try
+        let _reloc = Elf.Relocations.IMap.find_opt 0 relocations in
         let instr = Trace.Cache.get_instr (code, None) in (*TODO relocs*)
         if instr.traces = [] then begin
           debug "Instruction at %t in %s is loaded as special" (Pp.top Elf.Address.pp addr) sym.name;

From 8722715f7fe2bf4a345f8688ca23116eb5c201b0 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 9 Jan 2025 10:57:15 +0100
Subject: [PATCH 017/116] WIP

---
 src/isla/base.ml        | 20 +++++++++++++++
 src/isla/cache.ml       | 27 ++++++++-----------
 src/isla/preprocess.ml  |  7 +++--
 src/isla/preprocess.mli |  2 +-
 src/isla/server.ml      | 57 +++++++++++++++++++++++++----------------
 src/isla/test.ml        |  2 +-
 src/run/bb_lib.ml       |  7 ++---
 src/run/instr.ml        |  7 ++---
 src/trace/base.ml       |  3 ++-
 src/trace/cache.ml      |  7 +++--
 10 files changed, 87 insertions(+), 52 deletions(-)

diff --git a/src/isla/base.ml b/src/isla/base.ml
index 4cb88d85..94f4788b 100644
--- a/src/isla/base.ml
+++ b/src/isla/base.ml
@@ -97,6 +97,8 @@ type rsmt = lrng smt
 (** The type of raw expressions out of the parser *)
 type rexp = lrng exp
 
+type rtrcs = lrng trcs
+
 (*****************************************************************************)
 (*****************************************************************************)
 (*****************************************************************************)
@@ -173,6 +175,24 @@ let parse_trc_string ?(filename = "default") (s : string) : rtrc =
 let parse_trc_channel ?(filename = "default") (c : in_channel) : rtrc =
   parse_trc ~filename @@ Lexing.from_channel ~with_positions:true c
 
+let parse_trcs = parse Parser.trcs_start
+
+let parse_trcs_string ?filename (s : string) : rtrcs =
+  parse_trcs ?filename @@ Lexing.from_string ~with_positions:true s
+
+let parse_trcs_channel ?filename (c : in_channel) : rtrcs =
+  parse_trcs ?filename @@ Lexing.from_channel ~with_positions:true c
+
+let parse_segments ?filename l = match parse_trcs ?filename l with
+| TracesWithSegments (s, []) -> s
+| _ -> raise (ParseError (l.lex_start_p, "Data is not SEGMENTS"))
+
+let parse_segments_string ?filename (s : string) : instruction_segments =
+  parse_segments ?filename @@ Lexing.from_string ~with_positions:true s
+
+let parse_segments_channel ?filename (c : in_channel) : instruction_segments =
+  parse_segments ?filename @@ Lexing.from_channel ~with_positions:true c
+
 (*$R
     try
       let exp = parse_exp_string ~filename:"test" "v42" in
diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index f7d5850f..47845f36 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -126,23 +126,14 @@ end
 
     It is just a list of traces separated by new lines *)
 module TraceList (*: Cache.Value *) = struct
-  type t = Base.rtrc list
+  type t = Base.rtrcs
 
   let to_file file (trcs : t) =
-    let output_trc ochannel trc = Pp.fprintln ochannel @@ Base.pp_trc trc in
-    let output_trcs = Files.output_list output_trc in
-    Files.write output_trcs file trcs
+    Files.write Pp.fprintln file (Base.pp_trcs trcs)
 
   let of_file file : t =
-    let num = ref 0 in
-    let input_trc ichannel =
-      let trc = Files.input_sexp ichannel in
-      let filename = Printf.sprintf "Trace %i of %s" !num file in
-      incr num;
-      Base.parse_trc_string ~filename trc
-    in
-    let input_trcs = Files.input_list input_trc in
-    Files.read input_trcs file
+    let filename = Printf.sprintf "Traces of %s" file in
+    Files.read Files.input_string file |> Base.parse_trcs_string ~filename
 end
 
 (** An epoch independant of the isla version, bump if you change the representation
@@ -220,7 +211,7 @@ let get_cache () =
   match !cache with Some cache -> cache | None -> failwith "Isla cache was not started"
 
 (** Get the traces of the opcode given. Use {!Server} if the value is not in the cache *)
-let get_traces (opcode : Server.opcode) : Base.rtrc list =
+let get_traces (opcode : Server.opcode) : Base.rtrcs =
   let (cache, config) = get_cache () in
   match IC.get_opt cache (Some opcode) with
   | Some trcs -> trcs
@@ -237,11 +228,13 @@ let get_traces (opcode : Server.opcode) : Base.rtrc list =
 let get_nop () : Base.rtrc =
   let (cache, _) = get_cache () in
   match IC.get_opt cache None with
-  | Some [trc] -> trc
+  | Some (Traces [trc]) -> trc
+  | Some (TracesWithSegments _) -> fatal "Corrupted cache, nop has segments"
   | Some _ -> fatal "Corrupted cache, nop hasn't exactly one trace"
   | None ->
       ensure_started ();
-      let trcs = Server.request_bin_parsed @@ Arch.nop () in
+      let (segs, trcs) = Server.request_bin_parsed @@ Arch.nop () in
+      assert (Option.is_none segs);
       let trc = List.assoc true trcs in
-      IC.add cache None [trc];
+      IC.add cache None (Traces [trc]);
       trc
diff --git a/src/isla/preprocess.ml b/src/isla/preprocess.ml
index 0f187384..ec220f35 100644
--- a/src/isla/preprocess.ml
+++ b/src/isla/preprocess.ml
@@ -157,7 +157,7 @@ let simplify_trc (Trace events : rtrc) : rtrc =
     (1 + Counter.read new_variables);
   Trace (List.rev !res)
 
-let preprocess (config : Server.config) (trcs : (bool * rtrc) list) : rtrc list =
+let preprocess (config : Server.config) ((segs, trcs) : Server.trcs) : rtrcs =
   let preprocess_one (b, trc) =
     if not b then None
     else
@@ -165,4 +165,7 @@ let preprocess (config : Server.config) (trcs : (bool * rtrc) list) : rtrc list
       let trc = simplify_trc trc in
       Some trc
   in
-  List.filter_map preprocess_one trcs
+  let trcs = List.filter_map preprocess_one trcs in
+  match segs with
+  | None -> Traces (trcs)
+  | Some segs -> TracesWithSegments (segs, trcs)
diff --git a/src/isla/preprocess.mli b/src/isla/preprocess.mli
index b78fc41d..2b4ae5be 100644
--- a/src/isla/preprocess.mli
+++ b/src/isla/preprocess.mli
@@ -72,4 +72,4 @@ val simplify_trc : Base.rtrc -> Base.rtrc
 (** Preprocess a group of traces, by removing useless registers (according to
     the config), removing initialisation code and simplifying with
     {!simplify_trc} *)
-val preprocess : Server.config -> Server.trcs -> Base.rtrc list
+val preprocess : Server.config -> Server.trcs -> Base.rtrcs
diff --git a/src/isla/server.ml b/src/isla/server.ml
index 6c093fe3..acec119a 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -66,7 +66,7 @@ type config = Config.t
 
     It is a list of traces, each with a flag telling if they are normal traces (no
     processor exception/fault) or not *)
-type trcs = (bool * Base.rtrc) list
+type trcs = Base.instruction_segments option * (bool * Base.rtrc) list
 
 type reloc = Elf.Relocations.target
 
@@ -134,7 +134,7 @@ let raw_stop () =
   | None -> ()
 
 (** This should match exactly with the Answer type in isla-client code *)
-type basic_answer = Error | Version of string | StartTraces | Trace of bool * string | EndTraces
+type basic_answer = Error | Version of string | StartTraces | Trace of bool * string | EndTraces | Segments of string
 
 (** Read an answer from isla-client.
     This must match exactly [write_answer] in [client.rs] in [isla] *)
@@ -149,11 +149,12 @@ let read_basic_answer () =
       let s = Server.read_string serv in
       Trace (b, s)
   | 4 -> EndTraces
+  | 5 -> Segments (Server.read_string serv)
   | _ -> failwith "Unknown isla anwser"
 
 (** The interpreted answer. If the protocol is followed,
     then one request lead to exactly one answer of that type *)
-type answer = Version of string | Traces of (bool * string) list
+type answer = Version of string | Traces of (string option * (bool * string) list)
 
 (** Expect a version answer and fails if it is not the case *)
 let expect_version = function Version s -> s | _ -> failwith "expected version number from isla"
@@ -163,11 +164,15 @@ let expect_traces = function Traces tl -> tl | _ -> failwith "expected traces fr
 
 (** Expect isla traces and fails if it is not the case, additionally parse them *)
 let expect_parsed_traces a : trcs =
-  a |> expect_traces
-  |> List.mapi (fun i (b, t) ->
+  let rsegs, rtrcs = expect_traces a in
+  let filename = Printf.sprintf "Isla call %d" !req_num in
+  let trcs = List.mapi (fun i (b, t) ->
          ( b,
-           let filename = Printf.sprintf "Isla call %d, trace %d" !req_num i in
-           Base.parse_trc_string ~filename t ))
+           let filename = filename ^ Printf.sprintf ", trace %d" i in
+           Base.parse_trc_string ~filename t )) rtrcs
+  in
+  let segs = Option.map (Base.parse_segments_string ~filename) rsegs in
+  segs, trcs
 
 (** When isla encounter a non fatal error with that specific request.
     This error is recoverable and the sever can accept other requests *)
@@ -175,30 +180,38 @@ exception IslaError
 
 (** Read the answer from isla, block until full answer *)
 let read_answer () : answer =
+  let rec traces_seq () =
+    match read_basic_answer () with
+    | EndTraces -> Seq.Nil
+    | Trace (bool, s) -> Seq.Cons ((bool, s), traces_seq)
+    | Error -> raise IslaError
+    | _ -> failwith "isla protocol error: no EndTraces"
+  in
   match read_basic_answer () with
   | Error -> raise IslaError
   | Version s -> Version s
+  | Segments s -> (
+      match read_basic_answer () with
+      | StartTraces ->  Traces (Some s, List.of_seq traces_seq)
+      | _ -> failwith "segments not followed by traces"
+    )
   | StartTraces ->
-      let rec seq () =
-        match read_basic_answer () with
-        | EndTraces -> Seq.Nil
-        | Trace (bool, s) -> Seq.Cons ((bool, s), seq)
-        | Error -> raise IslaError
-        | _ -> failwith "isla protocol error: no EndTraces"
-      in
-      Traces (List.of_seq seq)
+      Traces (None, List.of_seq traces_seq)
   | _ -> failwith "isla protocol error: Traces element before StartTraces"
 
 (** Answer pretty printer *)
 let pp_answer = function
   | Version s -> Pp.(prefix 2 1 !^"isla-client version:" !^s)
-  | Traces l ->
-      l
-      |> List.map (fun (b, t) ->
-             Pp.(
-               let bdoc = if b then !^"norm:" else !^"ex:" in
-               prefix 2 1 bdoc (string t)))
-      |> Pp.(separate (hardline ^^ hardline))
+  | Traces (s, l) ->
+      Pp.(
+        optional string s
+        ^^ hardline 
+        ^^ hardline 
+        ^^ (l
+            |> List.map (fun (b, t) ->
+                let bdoc = if b then !^"norm:" else !^"ex:" in
+                prefix 2 1 bdoc (string t))
+            |> separate (hardline ^^ hardline)))
 
 (** The type of a request to isla *)
 type request = TEXT_ASM of string | ASM of BytesSeq.t | VERSION | STOP
diff --git a/src/isla/test.ml b/src/isla/test.ml
index c44343d6..d1e07e4e 100644
--- a/src/isla/test.ml
+++ b/src/isla/test.ml
@@ -204,7 +204,7 @@ let isla_run isla_mode arch (filename, input) : string * string * Server.config
         start config;
         let msg : string =
           match request (isla_mode_to_request isla_mode input) with
-          | Traces l -> List.assoc true l
+          | Traces (_, l) -> List.assoc true l (* TODO segments *)
           | _ -> failwith "isla did not send back traces"
         in
         stop ();
diff --git a/src/run/bb_lib.ml b/src/run/bb_lib.ml
index 477a9d98..6790fe1a 100644
--- a/src/run/bb_lib.ml
+++ b/src/run/bb_lib.ml
@@ -64,8 +64,9 @@ type t = { main : trc array }
     Also does the typing of traces for register discovery.
     TODO Support variable length instructions
 *)
-let from_binary (code : BytesSeq.t) : t =
-  let num = BytesSeq.length code / 4 in
+let from_binary (_code : BytesSeq.t) : t =
+  Raise.todo()
+  (* let num = BytesSeq.length code / 4 in
   (* TODO fix fixed size instructions *)
   if BytesSeq.length code != num * 4 then
     failwith "BB.from_binary: The specified range cuts an instruction";
@@ -83,7 +84,7 @@ let from_binary (code : BytesSeq.t) : t =
     (code, None) |> Isla.Cache.get_traces |> get_normal (*TODO relocs *)
   in
   let main = code |> BytesSeq.to_listbs ~len:4 |> List.map process |> Array.of_list in
-  { main }
+  { main } *)
 
 (* Sequence of the second test:
 mpool.c:116.6  (mpool_fini) 40012240:  37000049  tbnz
diff --git a/src/run/instr.ml b/src/run/instr.ml
index efa790bc..0098d35b 100644
--- a/src/run/instr.ml
+++ b/src/run/instr.ml
@@ -148,14 +148,15 @@ let simp_trace_term = Term.(const ( || ) $ simp_trace $ simp)
 
 let simp_state_term = Term.(const ( || ) $ simp_state $ simp)
 
-let get_traces instr isla_run dump_types : traces =
-  Isla.Cache.start @@ Arch.get_isla_config ();
+let get_traces _instr _isla_run _dump_types : traces =
+  Raise.todo()
+  (* Isla.Cache.start @@ Arch.get_isla_config ();
   (* I call Init.init manually to print the register types *)
   Init.init () |> ignore;
   let rtraces = Isla.Cache.get_traces (instr, None) in (* TODO relocs *)
   List.iter (fun t -> Isla.Type.type_trc t |> ignore) rtraces;
   if dump_types then base "Register types:\n%t\n" (Pp.topi State.Reg.pp_index ());
-  if isla_run then IslaTraces rtraces else Traces (List.map Trace.of_isla rtraces)
+  if isla_run then IslaTraces rtraces else Traces (List.map Trace.of_isla rtraces) *)
 
 let pre_traces_term = Term.(const get_traces $ instr_term $ isla_run $ reg_types)
 
diff --git a/src/trace/base.ml b/src/trace/base.ml
index eb0a88b0..891d3133 100644
--- a/src/trace/base.ml
+++ b/src/trace/base.ml
@@ -320,8 +320,9 @@ let events_of_isla ~written_registers ~read_counter ~(vc : value_context) :
   | AbstractCall _ -> []
   | AbstractPrimop _ -> []
 
+  (* TODO segments *)
 (** Top level function to convert an isla trace to one of this module *)
-let of_isla (Trace events : Isla.rtrc) : t =
+let of_isla (_segments: Isla.segment list) (Trace events : Isla.rtrc) : t =
   let written_registers = Hashtbl.create 10 in
   let read_counter = Counter.make 0 in
   let vc = HashVector.empty () in
diff --git a/src/trace/cache.ml b/src/trace/cache.ml
index 0f7d7e33..cd5e611b 100644
--- a/src/trace/cache.ml
+++ b/src/trace/cache.ml
@@ -160,8 +160,11 @@ let get_traces (opcode : Isla.Server.opcode) : Base.t list =
   match TC.get_opt cache (Some opcode) with
   | Some trcs -> trcs
   | None ->
-      let isla_traces = Isla.Cache.get_traces opcode in
-      let traces = List.map (tee (Isla.Type.type_trc %> ignore) %> Base.of_isla) isla_traces in
+      let segments, isla_traces = match Isla.Cache.get_traces opcode with
+      | Traces t -> [], t
+      | TracesWithSegments (Segments s, t) -> s, t
+      in 
+      let traces = List.map (tee (Isla.Type.type_trc %> ignore) %> Base.of_isla segments) isla_traces in
       let straces = List.map Base.simplify traces in
       TC.add cache (Some opcode) straces;
       straces

From 2d5379fb54038023bc3e9b9e8dd55d3d7aff78f5 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 9 Jan 2025 20:35:01 +0100
Subject: [PATCH 018/116] [WIP] symbolic traces

---
 src/arch/aarch64/sig.ml |  3 ++-
 src/elf/relocations.ml  | 14 ++++++++++++-
 src/elf/symbol.ml       |  2 +-
 src/isla/cache.ml       |  5 ++---
 src/isla/preprocess.ml  | 20 +++++++++++++-----
 src/isla/preprocess.mli |  2 +-
 src/isla/server.ml      | 34 +++++++++++++++++++++++++++---
 src/isla/test.ml        |  4 ++--
 src/run/runner.ml       |  8 ++++---
 src/trace/base.ml       | 46 +++++++++++++++++++++++++++++------------
 src/trace/context.ml    |  8 +------
 src/trace/instr.ml      |  2 +-
 src/trace/typer.ml      |  1 +
 13 files changed, 108 insertions(+), 41 deletions(-)

diff --git a/src/arch/aarch64/sig.ml b/src/arch/aarch64/sig.ml
index 658dab20..c46bb8b8 100644
--- a/src/arch/aarch64/sig.ml
+++ b/src/arch/aarch64/sig.ml
@@ -363,7 +363,8 @@ let assemble_to_elf instr =
 let split_into_instrs (data: Elf.Symbol.data) = 
   let module IMap = Elf.Relocations.IMap in
   let rawdata = BytesSeq.to_listbs ~len:4 data.data in
-  List.mapi (fun pos bytes -> 
+  List.mapi (fun i bytes ->
+      let pos = 4 * i in 
       let (_, rel, rest) = IMap.split pos data.relocations in
       if Option.is_some @@ IMap.find_first_opt (fun i -> i < pos + 4) rest then
         Raise.fail "Misaligned relocation";      
diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index e48871b7..b129d48f 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -25,8 +25,20 @@ let sub rels off len =
   |> List.filter_map (fun (pos, rel) -> if off <= pos && pos < off + len then Some (pos-off, rel) else None)
   |> IMap.of_list
 
+let pp_rel rel =
+  let target = match rel.target with
+  | AArch64 Abi_aarch64_symbolic_relocation.Data640 -> "Data64"
+  | AArch64 Abi_aarch64_symbolic_relocation.Data320 -> "Data32"
+  | AArch64 Abi_aarch64_symbolic_relocation.ADD -> "ADD"
+  | AArch64 Abi_aarch64_symbolic_relocation.ADRP -> "ADRP"
+  | AArch64 Abi_aarch64_symbolic_relocation.CALL -> "CALL"
+  | AArch64 Abi_aarch64_symbolic_relocation.LDST -> "LDST"
+  in
+  let expr = Elf_symbolic.pp_sym_expr rel.value in
+  Pp.(!^target ^^ !^": " ^^ !^expr)
+
 let pp rels =
   if IMap.is_empty rels then
     Pp.empty
   else
-    Pp.string "(has relocations)"
\ No newline at end of file
+    Pp.(mapping "relocations" @@ List.map (fun (i, r) -> (hex i, pp_rel r)) (IMap.to_list rels))
\ No newline at end of file
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 8bdce76a..263c184b 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -142,5 +142,5 @@ let pp_raw sym =
            (* ("addr", ptr sym.addr); *)
            ("size", ptr sym.size);
            ("writable", bool sym.writable);
-           ("data", BytesSeq.ppby ~by:4 sym.data.data ^^ Relocations.pp sym.data.relocations);
+           ("data", pair (BytesSeq.ppby ~by:4) Relocations.pp (sym.data.data, sym.data.relocations));
          ])
diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index 47845f36..a44cc8f3 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -217,8 +217,7 @@ let get_traces (opcode : Server.opcode) : Base.rtrcs =
   | Some trcs -> trcs
   | None ->
       ensure_started ();
-      let raw_opcode, _ = opcode in (*TODO*)
-      let trcs = Server.request_bin_parsed raw_opcode in
+      let trcs = Server.request_bin_parsed opcode in
       let ptrcs = Preprocess.preprocess config trcs in
       IC.add cache (Some opcode) ptrcs;
       ptrcs
@@ -233,7 +232,7 @@ let get_nop () : Base.rtrc =
   | Some _ -> fatal "Corrupted cache, nop hasn't exactly one trace"
   | None ->
       ensure_started ();
-      let (segs, trcs) = Server.request_bin_parsed @@ Arch.nop () in
+      let (segs, trcs) = Server.request_bin_parsed @@ (Arch.nop (), None) in
       assert (Option.is_none segs);
       let trc = List.assoc true trcs in
       IC.add cache None (Traces [trc]);
diff --git a/src/isla/preprocess.ml b/src/isla/preprocess.ml
index ec220f35..7aa0abd1 100644
--- a/src/isla/preprocess.ml
+++ b/src/isla/preprocess.ml
@@ -68,7 +68,7 @@ let expect_processed = function
   | _ -> Raise.fail "Variables should be processed at this point"
 
 (** Preprocess a single trace *)
-let simplify_trc (Trace events : rtrc) : rtrc =
+let simplify_trc ?(num_segments = 0) (Trace events : rtrc) : rtrc =
   (* Phase 1: Discover which variable are actually used *)
   let used = HashVector.empty () in
   let process_used event =
@@ -90,7 +90,8 @@ let simplify_trc (Trace events : rtrc) : rtrc =
      not yet commited are inlined.
      Variables are also renumbered at the same time. *)
   let simplify_context = HashVector.empty () in
-  let new_variables = Counter.make 0 in
+  (* Segment variables should not be renamed (we assume that those are v0-v(num_segments-1)) *)
+  let new_variables = Counter.make num_segments in
   let res = ref [] in
   let push_event (d : revent) = res := d :: !res in
   let push_smt loc (d : rsmt) = push_event (Smt (d, loc)) in
@@ -100,13 +101,13 @@ let simplify_trc (Trace events : rtrc) : rtrc =
     match HashVector.get simplify_context i with
     | Declared { ty; loc } ->
         debug "Commiting declared variable %d" i;
-        let new_val = Counter.get new_variables in
+        let new_val = if i < num_segments then i else Counter.get new_variables in
         HashVector.set simplify_context i (Processed new_val);
         push_smt loc (DeclareConst (new_val, ty));
         new_val
     | Defined { exp; loc } ->
         debug "Commiting defined variable %d" i;
-        let new_val = Counter.get new_variables in
+        let new_val = if i < num_segments then i else Counter.get new_variables in
         HashVector.set simplify_context i (Processed new_val);
         debug "New id is %d" new_val;
         let new_exp = simplify_exp exp in
@@ -158,11 +159,20 @@ let simplify_trc (Trace events : rtrc) : rtrc =
   Trace (List.rev !res)
 
 let preprocess (config : Server.config) ((segs, trcs) : Server.trcs) : rtrcs =
+  let num_segments =
+    segs
+    |> Option.map (fun (Segments s) -> 
+      let x = List.length s in
+      assert (List.for_all (fun (Segment (_,_,v)) -> v < x) s);
+      x
+    )
+    |> Option.value ~default:0
+  in
   let preprocess_one (b, trc) =
     if not b then None
     else
       let trc = trc |> Manip.remove_init |> Manip.remove_ignored config.ignored_regs in
-      let trc = simplify_trc trc in
+      let trc = simplify_trc ~num_segments trc in
       Some trc
   in
   let trcs = List.filter_map preprocess_one trcs in
diff --git a/src/isla/preprocess.mli b/src/isla/preprocess.mli
index 2b4ae5be..73c8a70f 100644
--- a/src/isla/preprocess.mli
+++ b/src/isla/preprocess.mli
@@ -67,7 +67,7 @@
 *)
 
 (** Simplify a simple trace by removing all useless variables *)
-val simplify_trc : Base.rtrc -> Base.rtrc
+val simplify_trc : ?num_segments:int -> Base.rtrc -> Base.rtrc
 
 (** Preprocess a group of traces, by removing useless registers (according to
     the config), removing initialisation code and simplifying with
diff --git a/src/isla/server.ml b/src/isla/server.ml
index acec119a..82bd8603 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -214,13 +214,41 @@ let pp_answer = function
             |> separate (hardline ^^ hardline)))
 
 (** The type of a request to isla *)
-type request = TEXT_ASM of string | ASM of BytesSeq.t | VERSION | STOP
+type request = TEXT_ASM of string | ASM of opcode | VERSION | STOP
+
+let pp_interpreted_opcode (b, r) =
+  match r with
+  | None -> Pp.(!^"#x" ^^ BytesSeq.ppint b)
+  | Some (Elf.Relocations.AArch64 rtype) ->
+      let bits = BytesSeq.getbvle ~size:32 b 0 in
+      Pp.(
+        match rtype with
+        | Abi_aarch64_symbolic_relocation.Data640 -> Raise.fail "64bit relocation not allowed for instruction"
+        | Abi_aarch64_symbolic_relocation.Data320 -> !^"x:32"
+        | Abi_aarch64_symbolic_relocation.ADRP -> 
+            BitVec.pp_smt (BitVec.extract 31 31 bits)  
+            ^^ !^" x0:2 " ^^
+            BitVec.pp_smt (BitVec.extract 24 28 bits)
+            ^^ !^" x1:19 " ^^
+            BitVec.pp_smt (BitVec.extract 0 4 bits)
+        | Abi_aarch64_symbolic_relocation.ADD -> 
+            BitVec.pp_smt (BitVec.extract 22 31 bits)  
+            ^^ !^" x0:12 " ^^
+            BitVec.pp_smt (BitVec.extract 0 9 bits)
+        | Abi_aarch64_symbolic_relocation.LDST -> (* TODO different width loads, alignment *) 
+            BitVec.pp_smt (BitVec.extract 22 31 bits)  
+            ^^ !^" x0:10 " ^^
+            BitVec.pp_smt (BitVec.extract 0 11 bits)
+        | Abi_aarch64_symbolic_relocation.CALL -> 
+            BitVec.pp_smt (BitVec.extract 26 31 bits)  
+            ^^ !^" x0:26 "
+      )
 
 (** Convert a request into the string message expected by isla-client
     This should match the protocol *)
 let string_of_request = function
   | TEXT_ASM s -> Printf.sprintf "execute_asm %s" s
-  | ASM b -> Pp.(sprintc @@ !^"execute " ^^ BytesSeq.ppint b)
+  | ASM b -> Pp.(sprintc @@ !^"execute " ^^ pp_interpreted_opcode b)
   | VERSION -> "version"
   | STOP -> "stop"
 
@@ -243,7 +271,7 @@ let request (req : request) : answer = req |> string_of_request |> string_reques
 
     This is the main entry point of this module.
 *)
-let request_bin_parsed (bin : BytesSeq.t) : trcs = ASM bin |> request |> expect_parsed_traces
+let request_bin_parsed (opcode : opcode) : trcs = ASM opcode |> request |> expect_parsed_traces
 
 (** Send a request without expecting any answer *)
 let send_request req = req |> string_of_request |> send_string_request
diff --git a/src/isla/test.ml b/src/isla/test.ml
index d1e07e4e..b7a06ad7 100644
--- a/src/isla/test.ml
+++ b/src/isla/test.ml
@@ -186,8 +186,8 @@ let isla_mode_term =
 let isla_mode_to_request imode input =
   match imode with
   | ASM -> Server.TEXT_ASM input
-  | HEX -> Server.ASM (BytesSeq.of_hex input)
-  | BIN -> Server.ASM (BytesSeq.of_string input)
+  | HEX -> Server.ASM (BytesSeq.of_hex input, None) (* TODO? *)
+  | BIN -> Server.ASM (BytesSeq.of_string input, None)
   | _ -> assert false
 
 (** Run isla and return a text trace with a filename
diff --git a/src/run/runner.ml b/src/run/runner.ml
index c3a4e031..dfc4ba73 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -94,7 +94,8 @@ let of_dwarf dwarf = of_elf ~dwarf dwarf.elf
 let load_sym runner (sym : Elf.Symbol.t) =
   info "Loading symbol %s in %s" sym.name runner.elf.filename;
   Vec.add_one runner.funcs sym.addr;
-  let opcode_list = Arch.split_into_instrs sym.data in (* TODO relocations *)
+  debug "Loding symbol %t" (Pp.top Elf.Symbol.pp_raw sym); 
+  let opcode_list = Arch.split_into_instrs sym.data in
   let addr = ref sym.addr in
   List.iter
     (fun Elf.Symbol.{ data = code; relocations } ->
@@ -103,9 +104,10 @@ let load_sym runner (sym : Elf.Symbol.t) =
         addr := Elf.Address.(!addr + len);
         (result, len)
       in
+      debug "Relocation at address %t: %t" (Pp.top Elf.Address.pp addr) (Pp.top Elf.Relocations.pp relocations);
       try
-        let _reloc = Elf.Relocations.IMap.find_opt 0 relocations in
-        let instr = Trace.Cache.get_instr (code, None) in (*TODO relocs*)
+        let reloc = Elf.Relocations.IMap.find_opt 0 relocations in
+        let instr = Trace.Cache.get_instr (code, Option.map (fun (x : Elf.Relocations.rel) -> x.target) reloc) in
         if instr.traces = [] then begin
           debug "Instruction at %t in %s is loaded as special" (Pp.top Elf.Address.pp addr) sym.name;
           Hashtbl.add runner.instrs addr (Special instr_len)
diff --git a/src/trace/base.ml b/src/trace/base.ml
index 891d3133..2419e7b7 100644
--- a/src/trace/base.ml
+++ b/src/trace/base.ml
@@ -93,6 +93,7 @@ module Var = struct
     | Register of Reg.t  (** The value of the register at the beginning of the trace *)
     | Read of int * Ast.Size.t  (** The result of that memory reading operation *)
     | NonDet of int * Ast.Size.t  (** Variable representing non-determinism in the spec *)
+    | Segment of string * int  (** Variable representing symbolic segment in the opcode *)
 
   (** Convert the variable to the string encoding. For parsing infractructure reason,
       the encoding must always contain at least one [:]. *)
@@ -104,6 +105,8 @@ module Var = struct
     | NonDet (num, size) ->
         if size = Ast.Size.B64 then Printf.sprintf "nondet:%i" num
         else Printf.sprintf "nondet:%i:%dbits" num (Ast.Size.to_bits size)
+    | Segment (name, bits) ->
+        Printf.sprintf "segment:%s:%dbits" name bits
 
   (** Inverse of {!to_string} *)
   let of_string s =
@@ -117,6 +120,9 @@ module Var = struct
     | ["nondet"; num; size] ->
         let size = Scanf.sscanf size "%dbits" Ast.Size.of_bits in
         NonDet (int_of_string num, size)
+    | ["segment"; name; bits] ->
+        let bits = Scanf.sscanf bits "%dbits" Fun.id in
+        Segment (name, bits)
     | _ -> Raise.inv_arg "%s is not a Base.Var.t" s
 
   (** Pretty prints the variable *)
@@ -130,6 +136,7 @@ module Var = struct
     | Register reg -> Reg.reg_type reg
     | Read (_, size) -> Ast.Ty_BitVec (Ast.Size.to_bits size)
     | NonDet (_, size) -> Ast.Ty_BitVec (Ast.Size.to_bits size)
+    | Segment (_, bits) -> Ast.Ty_BitVec bits
 
   let of_reg reg = Register reg
 end
@@ -248,17 +255,27 @@ let write_to_valu vc valu exp =
   match valu with Isla.(RegVal_Base (Val_Symbolic i)) -> HashVector.set vc i exp | _ -> ()
 
 (** Convert an isla event to Trace events, most events are deleted *)
-let events_of_isla ~written_registers ~read_counter ~(vc : value_context) :
+let events_of_isla ~segments_map ~written_registers ~read_counter ~(vc : value_context) :
     Isla.revent -> event list = function
   | Smt (DeclareConst (i, ty), _) ->
-      ( try
-          match ty with
-          | Ty_BitVec ((8 | 16 | 32 | 64 | 128) as size) ->
-              HashVector.set vc i (Exp.of_var (Var.NonDet (i, Ast.Size.of_bits size)))
-          | Ty_BitVec _ | Ty_Bool | Ty_Enum _ | Ty_Array (_, _) ->
-              debug "Unimplemented: ignoring non-det variable %i of type %t" i
-                (Pp.top Isla.pp_ty ty)
-        with OfIslaError -> warn "not setting nondet:%d" i
+      ( match HashVector.get_opt segments_map i with
+        | Some (name, size) ->
+            let ty_match = match ty with
+            | Ty_BitVec sz -> size = sz
+            | _ -> false
+            in
+            if not ty_match then fatal "Variable type doesn't match instruction segment %t and %d" (Pp.top Isla.pp_ty ty) size
+            else
+              HashVector.set vc i (Exp.of_var (Var.Segment (name, size)))
+        | None ->
+            try
+              match ty with
+              | Ty_BitVec ((8 | 16 | 32 | 64 | 128) as size) ->
+                  HashVector.set vc i (Exp.of_var (Var.NonDet (i, Ast.Size.of_bits size)))
+              | Ty_BitVec _ | Ty_Bool | Ty_Enum _ | Ty_Array (_, _) ->
+                  debug "Unimplemented: ignoring non-det variable %i of type %t" i
+                    (Pp.top Isla.pp_ty ty)
+            with OfIslaError -> warn "not setting nondet:%d" i
       );
       []
   | Smt (DefineConst (i, e), _) ->
@@ -320,13 +337,16 @@ let events_of_isla ~written_registers ~read_counter ~(vc : value_context) :
   | AbstractCall _ -> []
   | AbstractPrimop _ -> []
 
-  (* TODO segments *)
 (** Top level function to convert an isla trace to one of this module *)
-let of_isla (_segments: Isla.segment list) (Trace events : Isla.rtrc) : t =
+let of_isla (segments: Isla.segment list) (Trace events : Isla.rtrc) : t =
   let written_registers = Hashtbl.create 10 in
   let read_counter = Counter.make 0 in
   let vc = HashVector.empty () in
-  List.concat_map (events_of_isla ~written_registers ~read_counter ~vc) events
+  let segments_map = HashVector.empty () in
+  List.iter (fun (Isla.Segment (name, size, var)) -> 
+    HashVector.set segments_map var (name, size)
+  ) segments;
+  List.concat_map (events_of_isla ~segments_map  ~written_registers ~read_counter ~vc) events
 
 (*****************************************************************************)
 (*****************************************************************************)
@@ -346,7 +366,7 @@ let declare_non_det serv events =
   iter_var
     (function
       | Register _ | Read _ -> ()
-      | NonDet _ as var ->
+      | NonDet _ | Segment _ as var ->
           if not @@ VarTbl.mem declared @@ var then begin
             Z3Tr.declare_var_always serv var;
             VarTbl.add declared var ()
diff --git a/src/trace/context.ml b/src/trace/context.ml
index bfbce294..fb7a54a4 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -68,13 +68,7 @@ let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
   match v with
   | Register reg -> State.get_reg_exp ctxt.state reg
   | NonDet (i, _) | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
-
-let map_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.var =
-  assert (Base.Var.ty v = a);
-  match v with
-  | Register reg -> State.Var.Register (ctxt.state.id, reg)
-  | NonDet (i, size) -> State.Var.NonDet (i, size)
-  | Read (i, size) -> State.Var.ReadVar (ctxt.state.id, i, size)
+  | Segment (_name, size) -> Exp.Typed.bits (BitVec.zero ~size) (* TODO put the actual value there *)
 
 (** Tell if typing should enabled with this context *)
 let typing_enabled ~(ctxt : t) = ctxt.dwarf <> None
diff --git a/src/trace/instr.ml b/src/trace/instr.ml
index 4f0b54b9..25d1a9e5 100644
--- a/src/trace/instr.ml
+++ b/src/trace/instr.ml
@@ -81,7 +81,7 @@ let trace_meta_of_trace trace =
   let jump = ref None in
   let process_var = function
     | Base.Var.Register reg -> read := reg :: !read
-    | Base.Var.(Read _ | NonDet _) -> ()
+    | Base.Var.(Read _ | NonDet _ | Segment _) -> ()
   in
   let process_exp : Base.exp -> unit = Ast.Manip.exp_iter_var process_var in
   let process_event : Base.event -> unit = function
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index cf04c5af..238a17ef 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -203,6 +203,7 @@ let rec expr ~ctxt (exp : Base.exp) : Ctype.t option =
     | Var (Register reg, _) -> State.get_reg ctxt.state reg |> State.Tval.ctyp
     | Var (Read (r, _), _) -> HashVector.get ctxt.mem_reads r |> State.Tval.ctyp
     | Var (NonDet _, _) -> None
+    | Var (Segment _, _) -> None (* TODO? *)
     | Bits (bv, _) ->
         let size = BitVec.size bv in
         if size mod 8 = 0 || size = Arch.address_size then

From 36f77417fbb3113ed4a056ceee4b2f36d66006d3 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 10 Jan 2025 15:20:45 +0100
Subject: [PATCH 019/116] Store segments with instruction

---
 src/elf/relocations.ml | 39 +++++++++++++++++++++++++++++++++++----
 src/isla/server.ml     | 15 +++++++++++++--
 src/run/runner.ml      |  4 ++--
 src/trace/cache.ml     |  5 ++++-
 src/trace/instr.ml     | 27 ++++++++++++++++++++++-----
 5 files changed, 76 insertions(+), 14 deletions(-)

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index b129d48f..b253f100 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -3,19 +3,39 @@ module IMap = Map.Make (Int)
 type target =
   AArch64 of Abi_aarch64_symbolic_relocation.aarch64_relocation_target
 
+type binary_operation = Elf_symbolic.binary_operation
+
+type unary_operation = Elf_symbolic.unary_operation
+
+type exp =
+| Section of string
+| Const of int
+| BinOp of (exp * binary_operation * exp)
+| UnOp of (unary_operation * exp)
+(* | AssertRange of (exp * int * int) *)
+| Mask of (exp * int * int)
+
 type rel = {
   target : target;
-  value : Elf_symbolic.symbolic_expression;
+  value : exp;
 }
 
 type t = rel IMap.t
 
 type linksem_t = LinksemRelocatable.rels
 
+let rec exp_of_linksem = function
+| Elf_symbolic.Section s -> Section s
+| Elf_symbolic.Const x -> Const (Z.to_int x)
+| Elf_symbolic.BinOp (x, op, y) -> BinOp (exp_of_linksem x, op, exp_of_linksem y)
+| Elf_symbolic.UnOp (op, x) -> UnOp (op, exp_of_linksem x)
+| Elf_symbolic.AssertRange (x, _, _) -> exp_of_linksem x (* TODO *)
+| Elf_symbolic.Mask (x, a, b) -> Mask (exp_of_linksem x, Z.to_int a, Z.to_int b)
+
 let of_linksem: linksem_t -> t = function
 | LinksemRelocatable.AArch64 relocs ->
     let add k Elf_symbolic.{ arel_value; arel_target } m =
-      IMap.add (Z.to_int k) { value = arel_value; target = AArch64 arel_target } m
+      IMap.add (Z.to_int k) { value = exp_of_linksem arel_value; target = AArch64 arel_target } m
     in
     Pmap.fold add relocs IMap.empty
 
@@ -25,6 +45,17 @@ let sub rels off len =
   |> List.filter_map (fun (pos, rel) -> if off <= pos && pos < off + len then Some (pos-off, rel) else None)
   |> IMap.of_list
 
+let rec pp_exp = Pp.(
+  function
+  | Section s -> !^s
+  | Const x -> int x
+  | BinOp (a, Add, b) -> !^"(" ^^ pp_exp a ^^ !^"+" ^^ pp_exp b ^^ !^")"
+  | BinOp (a, Sub, b) -> !^"(" ^^ pp_exp a ^^ !^"-" ^^ pp_exp b ^^ !^")"
+  | BinOp (a, And, b) -> !^"(" ^^ pp_exp a ^^ !^"&" ^^ pp_exp b ^^ !^")"
+  | UnOp (Not, b) -> !^"(" ^^ !^"~" ^^ pp_exp b ^^ !^")"
+  | Mask (x, a, b) -> pp_exp x ^^ !^"[" ^^ int a ^^ !^":" ^^ int b ^^ !^"]"
+)
+
 let pp_rel rel =
   let target = match rel.target with
   | AArch64 Abi_aarch64_symbolic_relocation.Data640 -> "Data64"
@@ -34,8 +65,8 @@ let pp_rel rel =
   | AArch64 Abi_aarch64_symbolic_relocation.CALL -> "CALL"
   | AArch64 Abi_aarch64_symbolic_relocation.LDST -> "LDST"
   in
-  let expr = Elf_symbolic.pp_sym_expr rel.value in
-  Pp.(!^target ^^ !^": " ^^ !^expr)
+  let expr = pp_exp rel.value in
+  Pp.(!^target ^^ !^": " ^^ expr)
 
 let pp rels =
   if IMap.is_empty rels then
diff --git a/src/isla/server.ml b/src/isla/server.ml
index 82bd8603..a4fa0bb4 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -81,6 +81,8 @@ let reloc_id: reloc option -> int = function
 
 type opcode = BytesSeq.t * reloc option
 
+type reloc_segment = string * (int * int) (* mapping the name of a segment to the range of the relocation value *)
+
 (** Bump when updating isla.
     TODO: move the version checking to allow a range of version.
     Also, right now the cache invalidation is based on
@@ -223,8 +225,8 @@ let pp_interpreted_opcode (b, r) =
       let bits = BytesSeq.getbvle ~size:32 b 0 in
       Pp.(
         match rtype with
-        | Abi_aarch64_symbolic_relocation.Data640 -> Raise.fail "64bit relocation not allowed for instruction"
-        | Abi_aarch64_symbolic_relocation.Data320 -> !^"x:32"
+        | Abi_aarch64_symbolic_relocation.Data640 -> fatal "Data64 relocation not allowed for instruction"
+        | Abi_aarch64_symbolic_relocation.Data320 -> fatal "Data32 relocation not allowed for instruction"
         | Abi_aarch64_symbolic_relocation.ADRP -> 
             BitVec.pp_smt (BitVec.extract 31 31 bits)  
             ^^ !^" x0:2 " ^^
@@ -244,6 +246,15 @@ let pp_interpreted_opcode (b, r) =
             ^^ !^" x0:26 "
       )
 
+(* for interpreting the segments *)
+let segments_of_reloc: reloc -> reloc_segment list = function
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640 -> fatal "invalid relocation for instructions (Data64)"
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320 -> fatal "invalid relocation for instructions (Data32)"
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP -> ["x0", (0, 1); "x1", (2, 20)] (* or absolute? ["x0", (12, 13); "x1", (14, 32)] *)
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD -> ["x0", (0, 11)]
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST -> ["x0", (0, 9)] (* TODO depends on load size *) (* or absolute? ["x0", (2, 11)] *)
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL -> ["x0", (0, 25)] (* or absolute? ["x0", (2, 27)] *)
+
 (** Convert a request into the string message expected by isla-client
     This should match the protocol *)
 let string_of_request = function
diff --git a/src/run/runner.ml b/src/run/runner.ml
index dfc4ba73..d21193d3 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -107,7 +107,7 @@ let load_sym runner (sym : Elf.Symbol.t) =
       debug "Relocation at address %t: %t" (Pp.top Elf.Address.pp addr) (Pp.top Elf.Relocations.pp relocations);
       try
         let reloc = Elf.Relocations.IMap.find_opt 0 relocations in
-        let instr = Trace.Cache.get_instr (code, Option.map (fun (x : Elf.Relocations.rel) -> x.target) reloc) in
+        let instr = Trace.Cache.get_instr (code, reloc) in
         if instr.traces = [] then begin
           debug "Instruction at %t in %s is loaded as special" (Pp.top Elf.Address.pp addr) sym.name;
           Hashtbl.add runner.instrs addr (Special instr_len)
@@ -193,7 +193,7 @@ let skip runner state : State.t list =
     let pc = pc_exp |> Ast.expect_bits |> BitVec.to_int in
     let pc = Elf.Address.{ section = ".text"; offset = pc } in (* TODO this is wrong, should get symbolic value from pc_exp *)
     match fetch runner pc with
-    | Normal { traces = _; read = _; written = _; length; opcode = _ }
+    | Normal { traces = _; read = _; written = _; length; opcode = _; segments = _ }
      |Special length
      |IslaFail length ->
         let state = State.copy_if_locked state in
diff --git a/src/trace/cache.ml b/src/trace/cache.ml
index cd5e611b..7cb5625d 100644
--- a/src/trace/cache.ml
+++ b/src/trace/cache.ml
@@ -171,4 +171,7 @@ let get_traces (opcode : Isla.Server.opcode) : Base.t list =
 
 (** Get a full blown {!Instr} from the opcode, going through the whole Isla pipeline
     if necessary.*)
-let get_instr (opcode : Isla.Server.opcode) : Instr.t = Instr.of_traces opcode @@ get_traces opcode
+let get_instr (opcode : BytesSeq.t * Elf.Relocations.rel option) : Instr.t =
+  let raw_opcode, reloc = opcode in
+  let reloc_target = Option.map (fun (x : Elf.Relocations.rel) -> x.target) reloc in
+  Instr.of_traces opcode @@ get_traces (raw_opcode, reloc_target)
diff --git a/src/trace/instr.ml b/src/trace/instr.ml
index 25d1a9e5..012273a5 100644
--- a/src/trace/instr.ml
+++ b/src/trace/instr.ml
@@ -60,13 +60,16 @@ type trace_meta = {
   written : Reg.t list;
 }
 
+module SMap = Map.Make (String)
+
 (** A full instruction representation *)
 type t = {
   traces : trace_meta list;
   length : int;  (** Bytes length *)
   read : Reg.t list;
   written : Reg.t list;
-  opcode : Isla.Server.opcode;
+  opcode : BytesSeq.t;
+  segments: Elf.Relocations.exp SMap.t
 }
 
 let dedup_regs = List.sort_uniq State.Reg.compare
@@ -99,17 +102,31 @@ let trace_meta_of_trace trace =
   { trace; jump_target = !jump; read = dedup_regs !read; written = dedup_regs !written }
 
 (** Generate full instruction data from a list of traces *)
-let of_traces opcode traces =
+let of_traces (opcode: BytesSeq.t * Elf.Relocations.rel option) traces =
   let traces = List.map trace_meta_of_trace traces in
-  let raw_opcode, _ = opcode in
-  let length = BytesSeq.length raw_opcode in
+  let opcode, reloc = opcode in
+  let length = BytesSeq.length opcode in
   let read = dedup_regs @@ List.concat_map (fun (tr : trace_meta) -> tr.read) traces in
   let written = dedup_regs @@ List.concat_map (fun (tr : trace_meta) -> tr.written) traces in
-  { traces; length; read; written; opcode }
+
+  let segments = match reloc with
+  | None -> SMap.empty
+  | Some reloc ->
+      reloc.target
+      |> Isla.Server.segments_of_reloc
+      |> List.map (fun (v, (lo, hi)) -> (v, Elf.Relocations.Mask(reloc.value, hi, lo)))
+      |> SMap.of_list
+  in
+  { traces; length; read; written; opcode; segments }
 
 (** Pretty print the representation of an instruction *)
 let pp instr =
   let open Pp in
+  (prefix 4 1 !^"Segments:" @@
+    separate_map hardline
+      (pair string Elf.Relocations.pp_exp)
+      (SMap.to_list instr.segments))
+  ^^ hardline ^^
   separate_mapi hardline
     (fun i trc -> prefix 4 1 (dprintf "Trace %d:" i) (Base.pp trc.trace))
     instr.traces

From 90b3ac8106d8819cea250fa74bfab1ffc7db052b Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 10 Jan 2025 16:24:28 +0100
Subject: [PATCH 020/116] WIP eval relocations

---
 src/run/runner.ml    |  5 +++--
 src/trace/context.ml | 20 +++++++++++++++++---
 src/trace/run.ml     | 12 ++++++------
 3 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/src/run/runner.ml b/src/run/runner.ml
index d21193d3..a557708e 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -165,12 +165,13 @@ let fetch (runner : t) (pc : Elf.Address.t) : slot =
 let execute_normal ?(prelock = ignore) ~pc runner (instr : Trace.Instr.t) state =
   let dwarf = runner.dwarf in
   let next = instr.length in
+  let segments_map = instr.segments in
   let run_pure () =
     List.map
       (fun (trc : Trace.Instr.trace_meta) ->
         let nstate = State.copy state in
         State.set_last_pc nstate pc;
-        Trace.Run.trace_pc_mut ?dwarf ~next nstate trc.trace;
+        Trace.Run.trace_pc_mut ?dwarf ~segments_map ~next nstate trc.trace;
         nstate)
       instr.traces
   in
@@ -178,7 +179,7 @@ let execute_normal ?(prelock = ignore) ~pc runner (instr : Trace.Instr.t) state
     match instr.traces with
     | [trc] ->
         State.set_last_pc state pc;
-        Trace.Run.trace_pc_mut ?dwarf ~next state trc.trace;
+        Trace.Run.trace_pc_mut ?dwarf ~segments_map ~next state trc.trace;
         [state]
     | _ ->
         prelock state;
diff --git a/src/trace/context.ml b/src/trace/context.ml
index fb7a54a4..01da1e50 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -48,19 +48,33 @@
     should be added here
 *)
 
+module SMap = Map.Make (String)
+
 (** The context to run a trace *)
 type t = {
   reg_writes : (State.Reg.t * State.tval) Vec.t;  (** Stores the delayed register writes *)
   mem_reads : State.tval HashVector.t;  (** Stores the result of memory reads *)
   state : State.t;
+  segments : State.exp SMap.t;
   dwarf : Dw.t option;  (** Optionally DWARF information. If present, typing is enabled *)
 }
 
+let rec exp_of_relocation: Elf.Relocations.exp -> State.exp = 
+  let f = exp_of_relocation in function
+  | Section _ -> Exp.Typed.bits (BitVec.zero ~size:64) (* TODO put the actual value there, size? *)
+  | Const x -> Exp.Typed.bits (BitVec.of_int x ~size:64) (* TODO size? *)
+  | BinOp (a, Add, b) -> Exp.Typed.(f a + f b)
+  | BinOp (a, Sub, b) -> Exp.Typed.(f a - f b)
+  | BinOp (a, And, b) -> Exp.Typed.manyop (AstGen.Ott.Bvmanyarith AstGen.Ott.Bvand) [f a; f b]
+  | UnOp (Not, b) -> Exp.Typed.unop AstGen.Ott.Bvnot (f b)
+  | Mask (x, last, first) -> Exp.Typed.extract ~last ~first (f x)
+
 (** Build a {!context} from a state *)
-let make_context ?dwarf state =
+let make_context ?dwarf ?segments_map state =
   let reg_writes = Vec.empty () in
   let mem_reads = HashVector.empty () in
-  { state; reg_writes; mem_reads; dwarf }
+  let segments = segments_map |> Option.value ~default:SMap.empty |> SMap.map exp_of_relocation in
+  { state; reg_writes; mem_reads; dwarf; segments }
 
 (** Expand a Trace variable to a State expression, using the context *)
 let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
@@ -68,7 +82,7 @@ let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
   match v with
   | Register reg -> State.get_reg_exp ctxt.state reg
   | NonDet (i, _) | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
-  | Segment (_name, size) -> Exp.Typed.bits (BitVec.zero ~size) (* TODO put the actual value there *)
+  | Segment (name, _) -> SMap.find name ctxt.segments (* TODO put the actual value there *)
 
 (** Tell if typing should enabled with this context *)
 let typing_enabled ~(ctxt : t) = ctxt.dwarf <> None
diff --git a/src/trace/run.ml b/src/trace/run.ml
index f6eaf1c1..df944ca7 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -114,17 +114,17 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
   | Assert exp -> State.push_assert ctxt.state (expand ~ctxt exp)
 
 (** Run a trace on the provided state by mutation. Enable typing if [dwarf] is provided *)
-let trace_mut ?dwarf (state : State.t) (events : Base.t) : unit =
+let trace_mut ?dwarf ?segments_map (state : State.t) (events : Base.t) : unit =
   assert (not @@ State.is_locked state);
   info "Running trace with typing %s" (if dwarf <> None then "on" else "off");
-  let ctxt = Context.make_context ?dwarf state in
+  let ctxt = Context.make_context ?dwarf ?segments_map state in
   List.iter (event_mut ~ctxt) events;
   Vec.iter (fun (reg, tval) -> State.Reg.Map.set state.regs reg tval) ctxt.reg_writes
 
 (** Run a trace on the provided state by returning an updated copy.*)
-let trace ?dwarf (start : State.t) (events : Base.t) : State.t =
+let trace ?dwarf ?segments_map (start : State.t) (events : Base.t) : State.t =
   let state = State.copy start in
-  trace_mut ?dwarf state events;
+  trace_mut ?dwarf ?segments_map state events;
   State.lock state;
   state
 
@@ -133,12 +133,12 @@ let trace ?dwarf (start : State.t) (events : Base.t) : State.t =
 
     Thus this function automatically handle moving the PC for fall-through instruction
 *)
-let trace_pc_mut ?dwarf ~(next : int) (state : State.t) (events : Base.t) : unit =
+let trace_pc_mut ?dwarf ?segments_map ~(next : int) (state : State.t) (events : Base.t) : unit =
   let pc = Arch.pc () in
   let rec is_touching_pc : Base.t -> bool = function
     | [] -> false
     | WriteReg { reg; _ } :: _ when reg = pc -> true
     | _ :: l -> is_touching_pc l
   in
-  trace_mut ?dwarf state events;
+  trace_mut ?dwarf ?segments_map state events;
   if is_touching_pc events then State.concretize_pc ~pc state else State.bump_pc ~pc state next

From 34824b143fe367f9bdeaf3faf30f29f7e597eb64 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 12 Jan 2025 12:14:57 +0100
Subject: [PATCH 021/116] Symbolic section addresses

---
 src/state/base.ml    | 6 ++++++
 src/state/base.mli   | 2 ++
 src/trace/context.ml | 2 +-
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 4cda529c..5b054155 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -76,6 +76,8 @@ module Var = struct
     | NonDet of int * Ast.Size.t
         (** Variable representing non-determinism in the spec.
             Can only be bit-vectors of size {8, 16, 32, 64} for now. *)
+    | Section of string
+        (** Symbolic base address of ELF section. Assume 64bit for now. *)
 
   let to_string = function
     | Register (state, reg) ->
@@ -90,6 +92,7 @@ module Var = struct
     | NonDet (num, size) ->
         if size = Ast.Size.B64 then Printf.sprintf "nondet:%i" num
         else Printf.sprintf "nondet:%i:%dbits" num (Ast.Size.to_bits size)
+    | Section s -> "section:"^s
 
   let expect_register = function
     | Register (_, reg) -> reg
@@ -125,6 +128,7 @@ module Var = struct
     | ["arg"; num] -> Arg (int_of_string num)
     | ["retarg"; ""] -> RetArg
     | ["retaddr"; ""] -> RetAddr
+    | ["section"; s] -> Section s
     | _ -> Raise.inv_arg "Invalid state variable: %s" s
 
   let of_reg id reg = Register (id, reg)
@@ -138,6 +142,7 @@ module Var = struct
     | (RetArg, RetArg) -> true
     | (RetAddr, RetAddr) -> true
     | (NonDet (num, size), NonDet (num', size')) -> num = num' && size = size'
+    | (Section s, Section s') -> s = s'
     | _ -> false
 
   let hash = Hashtbl.hash
@@ -153,6 +158,7 @@ module Var = struct
     | RetArg -> Ast.Ty_BitVec 64
     | RetAddr -> Ast.Ty_BitVec 64
     | NonDet (_, size) -> Ast.Ty_BitVec (Ast.Size.to_bits size)
+    | Section _ -> Ast.Ty_BitVec 64
 end
 
 type var = Var.t
diff --git a/src/state/base.mli b/src/state/base.mli
index 05669eb6..b65853c3 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -113,6 +113,8 @@ module Var : sig
     | RetAddr  (** The return address: The address to which a "return" instruction would jump. *)
     | NonDet of int * Ast.Size.t
         (** Variable representing non-determinism in the spec. Can only be a bit-vector for now. *)
+    | Section of string
+    (** Symbolic base address of ELF section. Assume 64bit for now. *)
 
   (** Convert the variable to the string encoding. For parsing infrastructure reason,
       the encoding must always contain at least one [:]. *)
diff --git a/src/trace/context.ml b/src/trace/context.ml
index 01da1e50..d3cbd143 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -61,7 +61,7 @@ type t = {
 
 let rec exp_of_relocation: Elf.Relocations.exp -> State.exp = 
   let f = exp_of_relocation in function
-  | Section _ -> Exp.Typed.bits (BitVec.zero ~size:64) (* TODO put the actual value there, size? *)
+  | Section s -> State.Exp.of_var (State.Var.Section s) (* TODO put the actual value there, size? *)
   | Const x -> Exp.Typed.bits (BitVec.of_int x ~size:64) (* TODO size? *)
   | BinOp (a, Add, b) -> Exp.Typed.(f a + f b)
   | BinOp (a, Sub, b) -> Exp.Typed.(f a - f b)

From 897e638fb6c98542d8f471dbb3c656983cc6d05c Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 12 Jan 2025 12:41:23 +0100
Subject: [PATCH 022/116] Fix cache

---
 src/elf/relocations.ml | 19 +++++++++----------
 src/isla/cache.ml      |  9 +++++----
 src/isla/server.ml     | 10 ++++++++++
 3 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index b253f100..8bf736ce 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -56,17 +56,16 @@ let rec pp_exp = Pp.(
   | Mask (x, a, b) -> pp_exp x ^^ !^"[" ^^ int a ^^ !^":" ^^ int b ^^ !^"]"
 )
 
+let pp_target = Pp.(function
+| AArch64 Abi_aarch64_symbolic_relocation.Data640 -> !^"Data64"
+| AArch64 Abi_aarch64_symbolic_relocation.Data320 -> !^"Data32"
+| AArch64 Abi_aarch64_symbolic_relocation.ADD -> !^"ADD"
+| AArch64 Abi_aarch64_symbolic_relocation.ADRP -> !^"ADRP"
+| AArch64 Abi_aarch64_symbolic_relocation.CALL -> !^"CALL"
+| AArch64 Abi_aarch64_symbolic_relocation.LDST -> !^"LDST")
+
 let pp_rel rel =
-  let target = match rel.target with
-  | AArch64 Abi_aarch64_symbolic_relocation.Data640 -> "Data64"
-  | AArch64 Abi_aarch64_symbolic_relocation.Data320 -> "Data32"
-  | AArch64 Abi_aarch64_symbolic_relocation.ADD -> "ADD"
-  | AArch64 Abi_aarch64_symbolic_relocation.ADRP -> "ADRP"
-  | AArch64 Abi_aarch64_symbolic_relocation.CALL -> "CALL"
-  | AArch64 Abi_aarch64_symbolic_relocation.LDST -> "LDST"
-  in
-  let expr = pp_exp rel.value in
-  Pp.(!^target ^^ !^": " ^^ expr)
+  Pp.(pp_target rel.target ^^ !^": " ^^ pp_exp rel.value)
 
 let pp rels =
   if IMap.is_empty rels then
diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index a44cc8f3..98d7dfa2 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -86,7 +86,7 @@ module Opcode (*: Cache.Key *) = struct
     | _ -> false
 
   let small_enough bs rel_id =
-    BytesSeq.length bs < BytesSeq.int_bytes && rel_id < 16
+    BytesSeq.length bs < BytesSeq.int_bytes && rel_id < 8
 
   let hash = function
     | None -> 0
@@ -97,7 +97,7 @@ module Opcode (*: Cache.Key *) = struct
         if small_enough bs rel_id then begin
           assert (not @@ IntBits.get i IntBits.back);
           let res = IntBits.blit l 0 i (IntBits.back - 3) 3 in
-          let res = IntBits.blit rel_id 0 res (IntBits.back - 7) 4 in
+          let res = IntBits.blit rel_id 0 res (IntBits.back - 6) 3 in
           res
         end
         else IntBits.set i IntBits.back
@@ -115,11 +115,12 @@ module Opcode (*: Cache.Key *) = struct
     else if IntBits.get hash IntBits.back then
       Raise.todo()
     else
-      let data = IntBits.sub hash 0 (IntBits.back - 3) in
+      let data = IntBits.sub hash 0 (IntBits.back - 6) in
+      let reloc_id = IntBits.sub hash (IntBits.back - 6) 3 in
       let size = IntBits.sub hash (IntBits.back - 3) 3 in
       let b = Bytes.create size in
       Bits.unsafe_blit_of_int data 0 b 0 (size * 8);
-      Some (BytesSeq.of_bytes b, None)
+      Some (BytesSeq.of_bytes b, Server.reloc_of_id reloc_id)
 end
 
 (** Representation of trace lists on disk.
diff --git a/src/isla/server.ml b/src/isla/server.ml
index a4fa0bb4..b2ba008b 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -79,6 +79,16 @@ let reloc_id: reloc option -> int = function
 | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST) -> 5
 | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 6
 
+let reloc_of_id: int -> reloc option = function
+| 0 -> None
+| 1 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640)
+| 2 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320)
+| 3 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP)
+| 4 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD)
+| 5 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST)
+| 6 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL)
+| _ -> Raise.fail "invalid reloc id"
+
 type opcode = BytesSeq.t * reloc option
 
 type reloc_segment = string * (int * int) (* mapping the name of a segment to the range of the relocation value *)

From 88cb3402a5b97b7e8f11d472ce67266016a9b4fd Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 14 Jan 2025 15:32:11 +0100
Subject: [PATCH 023/116] Make PC symbolic in isla

---
 src/config/config.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/config/config.toml b/src/config/config.toml
index 2497ed77..9c968490 100644
--- a/src/config/config.toml
+++ b/src/config/config.toml
@@ -66,7 +66,7 @@ toolchain = "aarch64-linux-gnu"
     arch-file = "../../aarch64.ir" # relative to the toml file
     arch-toml = "isla_aarch64.toml" # relative to the toml file
     linearize = ["ConditionHolds", "integer_conditional_select", "InterruptPending"]
-    other-opts = []
+    other-opts = ["-R", "_PC=undefined:%bv64"]
 
 [archs.riscv64]
 toolchain = "riscv64-linux-gnu"

From ebf0b274049993f5dab4423225507a6182d44cb2 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 14 Jan 2025 18:23:24 +0100
Subject: [PATCH 024/116] Symbolic PC

---
 src/elf/address.ml   | 16 +++++++++++++++-
 src/run/block_lib.ml | 30 +++++++++++++-----------------
 src/run/runner.ml    |  6 ++----
 src/state/base.ml    | 22 +++++++++++++++++-----
 src/state/base.mli   |  2 ++
 5 files changed, 49 insertions(+), 27 deletions(-)

diff --git a/src/elf/address.ml b/src/elf/address.ml
index c9f3b66b..701ddd89 100644
--- a/src/elf/address.ml
+++ b/src/elf/address.ml
@@ -7,4 +7,18 @@ let pp addr = Pp.(!^(addr.section) ^^ !^"+" ^^ ptr addr.offset)
 
 let of_linksem (section, offset) = { section; offset = Z.to_int offset }
 
-let (+) addr offset = { section = addr.section; offset = addr.offset + offset }
\ No newline at end of file
+let (+) addr offset = { section = addr.section; offset = addr.offset + offset }
+
+let compare f {section=s1; offset=o1} {section=s2; offset=o2} =
+  if s1 = s2 then
+    Some (f o1 o2)
+  else
+    None
+
+let (<) = compare (<)
+
+let (>) = compare (>)
+
+let (<=) = compare (<=)
+
+let (>=) = compare (>=)
diff --git a/src/run/block_lib.ml b/src/run/block_lib.ml
index ddb6c14d..2d548c75 100644
--- a/src/run/block_lib.ml
+++ b/src/run/block_lib.ml
@@ -107,7 +107,7 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
             State.lock state
           end;
           let states =
-            let pc = pc_exp |> Ast.expect_bits |> BitVec.to_int in
+            let pc = State.Exp.expect_sym_address pc_exp in
             if Option.fold ~none:true ~some:(Fun.flip Hashtbl.mem pc) relevant then (
               info "Running pc %t" (Pp.top State.Exp.pp pc_exp);
               Runner.run ~prelock b.runner state
@@ -148,12 +148,6 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
     - pc has be seen more than [loop]
 *)
 let gen_endpred ?min ?max ?loop ?(brks = []) () : State.exp -> string option =
-  (* HACK *)
-  (* TODO rewrite for symbolic pc *)
-  let min = Option.map (fun min -> min.Elf.Address.offset) min in
-  let max = Option.map (fun max -> max.Elf.Address.offset) max in
-  let brks = List.map (fun brks -> brks.Elf.Address.offset) brks in
-  (*  *)
   let endnow fmt = Printf.ksprintf Option.some fmt in
   let pchtbl = Hashtbl.create 10 in
   let loop_str =
@@ -164,21 +158,23 @@ let gen_endpred ?min ?max ?loop ?(brks = []) () : State.exp -> string option =
     | Some n -> Printf.sprintf "%d times" n
     | None -> ""
   in
-  function
-  | Ast.Bits (bv, _) -> (
-      let pc = BitVec.to_int bv in
-      debug "enpred: Evaluating PC 0x%x" pc;
+  fun pc_exp ->
+    ( try
+      Some (State.Exp.expect_sym_address pc_exp)
+    with
+      _ -> None
+    ) |> Option.map (fun pc ->
+      debug "enpred: Evaluating PC %t" (Pp.top Elf.Address.pp pc);
       match (min, max, loop) with
-      | (Some min, _, _) when pc < min -> endnow "PC 0x%x was below min 0x%x" pc min
-      | (_, Some max, _) when pc >= max -> endnow "PC 0x%x was above max 0x%x" pc max
-      | _ when List.exists (( = ) pc) brks -> endnow "PC 0x%x hit a breakpoint" pc
+      | (Some min, _, _) when Elf.Address.(pc < min) <> Some false -> endnow "PC %t was below min %t" Pp.(tos Elf.Address.pp pc) Pp.(tos Elf.Address.pp min)
+      | (_, Some max, _) when Elf.Address.(pc >= max) <> Some false -> endnow "PC %t was above max %t" Pp.(tos Elf.Address.pp pc) Pp.(tos Elf.Address.pp max)
+      | _ when List.exists (( = ) pc) brks -> endnow "PC %t hit a breakpoint" Pp.(tos Elf.Address.pp pc)
       | (_, _, Some loop) ->
           let current_num = Hashtbl.find_opt pchtbl pc |> Option.value ~default:0 in
-          if current_num >= loop then endnow "PC 0x%x had been seen more than %s" pc loop_str
+          if current_num >= loop then endnow "PC %t had been seen more than %s" Pp.(tos Elf.Address.pp pc) loop_str
           else begin
             Hashtbl.replace pchtbl pc (current_num + 1);
             None
           end
       | _ -> None
-    )
-  | exp -> endnow "PC %t is symbolic" Pp.(tos State.Exp.pp exp)
+    ) |> Option.value_fun ~default:(fun () -> endnow "PC %t is symbolic" Pp.(tos State.Exp.pp pc_exp))
diff --git a/src/run/runner.ml b/src/run/runner.ml
index a557708e..fda103e4 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -191,8 +191,7 @@ let execute_normal ?(prelock = ignore) ~pc runner (instr : Trace.Instr.t) state
 let skip runner state : State.t list =
   let pc_exp = State.get_reg_exp state runner.pc in
   try
-    let pc = pc_exp |> Ast.expect_bits |> BitVec.to_int in
-    let pc = Elf.Address.{ section = ".text"; offset = pc } in (* TODO this is wrong, should get symbolic value from pc_exp *)
+    let pc = State.Exp.expect_sym_address pc_exp in
     match fetch runner pc with
     | Normal { traces = _; read = _; written = _; length; opcode = _; segments = _ }
      |Special length
@@ -224,8 +223,7 @@ let skip runner state : State.t list =
 let run ?prelock runner state : State.t list =
   let pc_exp = State.get_reg_exp state runner.pc in
   try
-    let pc = pc_exp |> Ast.expect_bits |> BitVec.to_int in
-    let pc = Elf.Address.{ section = ".text"; offset = pc } in (* TODO this is wrong, should get symbolic value from pc_exp *)
+    let pc = State.Exp.expect_sym_address pc_exp in
     match fetch runner pc with
     | Normal instr -> execute_normal ?prelock ~pc runner instr state
     | Special _ ->
diff --git a/src/state/base.ml b/src/state/base.ml
index 5b054155..489bc5fc 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -172,6 +172,15 @@ module Exp = struct
   include Exp.Make (Var)
 
   let of_reg id reg = Var.of_reg id reg |> of_var
+
+  let expect_sym_address exp =
+    let sym, conc = Exp.Sums.split_concrete exp in
+    let section = match sym with
+    | Some(Ast.Var (Var.Section s, _)) -> s
+    | _ -> Raise.fail "Expected symbolic Section base"
+    in
+    let offset = BitVec.to_int conc in
+    Elf.Address.{ section; offset }
 end
 
 type exp = Exp.t
@@ -507,16 +516,19 @@ let set_pc ~(pc : Reg.t) (s : t) (pcval : int) =
 
 (* TODO *)
 let set_pc_sym ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
-  set_pc ~pc s pcval.offset
+  (* set_pc ~pc s pcval.offset *)
+  let exp = Typed.(var ~typ:(Ty_BitVec 64) (Var.Section pcval.section) + bits_int ~size:64 pcval.offset) in
+  let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval.offset ~constexpr:true in
+  set_reg s pc @@ Tval.make ~ctyp exp
   
 
 let bump_pc ~(pc : Reg.t) (s : t) (bump : int) =
   let pc_exp = get_reg_exp s pc in
-  assert (ConcreteEval.is_concrete pc_exp);
-  let old_pc = ConcreteEval.eval pc_exp |> Value.expect_bv |> BitVec.to_int in
-  let new_pc = old_pc + bump in
-  set_pc ~pc s new_pc
+  let old_pc = Exp.expect_sym_address pc_exp in
+  let new_pc = Elf.Address.(old_pc + bump) in
+  set_pc_sym ~pc s new_pc
 
+(* TODO section + offset *)
 let concretize_pc ~(pc : Reg.t) (s : t) =
   let pc_exp = get_reg_exp s pc in
   try ConcreteEval.eval pc_exp |> Value.expect_bv |> BitVec.to_int |> set_pc ~pc s
diff --git a/src/state/base.mli b/src/state/base.mli
index b65853c3..bcba6c5f 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -158,6 +158,8 @@ module Exp : sig
 
   (** Create an expression from an register and a state id *)
   val of_reg : id -> Reg.t -> t
+
+  val expect_sym_address : t -> Elf.Address.t
 end
 
 type exp = Exp.t

From dde2e988439d0f7e2c5e4eca56c2a4619d67ebf0 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 15 Jan 2025 16:47:09 +0100
Subject: [PATCH 025/116] WIP

---
 src/exp/sums.ml      | 20 ++++++++++++++++++++
 src/state/base.ml    |  5 +++++
 src/trace/context.ml |  3 ++-
 src/utils/list.ml    | 14 ++++++++++++++
 4 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/src/exp/sums.ml b/src/exp/sums.ml
index 4d945032..6d843f5d 100644
--- a/src/exp/sums.ml
+++ b/src/exp/sums.ml
@@ -42,6 +42,10 @@
 (*                                                                                  *)
 (*==================================================================================*)
 
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
 (* The documentation is in the mli file *)
 
 let rec split =
@@ -59,6 +63,20 @@ let rec split =
       let l' = split e' in
       let rl' = List.rev_map Typed.neg l' in
       List.rev_append rl' l
+  | Manyop (Concat, l, _) ->
+      let all_splits = List.map split l in
+      let defaults = List.map (fun e ->
+        let size = e |> Typed.get_type |> Typed.expect_bv in
+        Typed.bits_int ~size 0
+      ) l in
+      let terms = List.transpose ~defaults all_splits in
+      List.map Typed.concat terms
+  | Unop (ZeroExtend m, e, _) ->
+      let l = split e in
+      List.map (Typed.unop (ZeroExtend m)) l
+  | Unop (SignExtend s, e, _) ->
+      let l = split e in
+      List.map (Typed.unop (SignExtend s)) l
   | e -> [e]
 
 let merge ~size l = if l = [] then Typed.zero ~size else Typed.sum l
@@ -88,6 +106,8 @@ let smart_substract ~equal ~term exp =
 let split_concrete exp =
   let size = Typed.expect_bv (Typed.get_type exp) in
   let terms = split exp in
+  debug "Split:";
+  List.iter (fun t -> debug "\t%t" Pp.(top (PpExp.pp_exp (fun _ -> !^"var")) t)) terms;
   let (symterms, concvals) = List.partition_map ConcreteEval.eval_if_concrete terms in
   let concbvs = List.map Value.expect_bv concvals in
   let concbv = List.fold_left BitVec.( + ) (BitVec.zero ~size) concbvs in
diff --git a/src/state/base.ml b/src/state/base.ml
index 489bc5fc..55606fc8 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -163,6 +163,8 @@ end
 
 type var = Var.t
 
+module Z3St = Z3.Make (Var)
+
 module Sums = Exp.Sums
 module Typed = Exp.Typed
 module ConcreteEval = Exp.ConcreteEval
@@ -474,6 +476,9 @@ let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t
   Option.value exp ~default:(Exp.of_var var)
 
 let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+  (* let addr = Z3St.simplify_full addr in *)
+  let sym, conc = Sums.split_concrete addr in
+  debug "Address: %t + %t" Pp.(top (optional Exp.pp) sym) Pp.(top BitVec.pp_smt conc);
   if ConcreteEval.is_concrete addr || Vec.length s.mem.frags = 0 then
     read ~provenance:Ctype.Main ?ctyp s ~addr ~size
   else Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
diff --git a/src/trace/context.ml b/src/trace/context.ml
index d3cbd143..3ed8317d 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -82,7 +82,8 @@ let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
   match v with
   | Register reg -> State.get_reg_exp ctxt.state reg
   | NonDet (i, _) | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
-  | Segment (name, _) -> SMap.find name ctxt.segments (* TODO put the actual value there *)
+  | Segment (name, _) -> SMap.find name ctxt.segments (*TODO put the actual value there*)
+  (* | Segment (name, sz) -> Exp.Typed.extract ~first:0 ~last:(sz-1) (State.Exp.of_var (State.Var.Section name)) TODO put the actual value there *)
 
 (** Tell if typing should enabled with this context *)
 let typing_enabled ~(ctxt : t) = ctxt.dwarf <> None
diff --git a/src/utils/list.ml b/src/utils/list.ml
index 5eae6c30..6eb978ca 100644
--- a/src/utils/list.ml
+++ b/src/utils/list.ml
@@ -298,3 +298,17 @@ let prod l1 l2 =
 
 (** Monadic merge. [let* x = xl and* y = yl in ... = let* x= xl in let* y = yl in ...] *)
 let ( and* ) = prod
+
+let hd_opt = function
+| [] -> None
+| h :: _ -> Some h
+
+let rec transpose ~defaults l =
+  let first = map hd_opt l in
+  let rest = map (drop 1) l in
+  if for_all Stdlib.Option.is_none first then
+    []
+  else
+    let t = transpose ~defaults rest in
+    let h = combine first defaults |> map (fun (value, default) -> Stdlib.Option.value ~default value) in
+    h :: t

From 516f4f1d4a0e95fb7e5e92f0a0322e0585b277a8 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 15 Jan 2025 22:27:36 +0100
Subject: [PATCH 026/116] wip

---
 src/elf/relocations.ml | 34 +++++++++++++++-------
 src/isla/cache.ml      | 25 ++++++++++++++--
 src/isla/isla.ml       |  1 +
 src/isla/relocation.ml | 44 ++++++++++++++++++++++++++++
 src/isla/server.ml     | 65 ++----------------------------------------
 src/run/runner.ml      |  8 +++---
 src/trace/context.ml   | 36 +++++++++++++++++++----
 src/trace/instr.ml     | 21 +++-----------
 src/trace/run.ml       | 12 ++++----
 9 files changed, 138 insertions(+), 108 deletions(-)
 create mode 100644 src/isla/relocation.ml

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index 8bf736ce..e9295717 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -13,29 +13,41 @@ type exp =
 | BinOp of (exp * binary_operation * exp)
 | UnOp of (unary_operation * exp)
 (* | AssertRange of (exp * int * int) *)
-| Mask of (exp * int * int)
+(* | Mask of (exp * int * int) *)
 
 type rel = {
   target : target;
   value : exp;
+  range: (int64 * int64) option;
+  mask : int * int;
 }
 
 type t = rel IMap.t
 
 type linksem_t = LinksemRelocatable.rels
 
-let rec exp_of_linksem = function
-| Elf_symbolic.Section s -> Section s
-| Elf_symbolic.Const x -> Const (Z.to_int x)
-| Elf_symbolic.BinOp (x, op, y) -> BinOp (exp_of_linksem x, op, exp_of_linksem y)
-| Elf_symbolic.UnOp (op, x) -> UnOp (op, exp_of_linksem x)
-| Elf_symbolic.AssertRange (x, _, _) -> exp_of_linksem x (* TODO *)
-| Elf_symbolic.Mask (x, a, b) -> Mask (exp_of_linksem x, Z.to_int a, Z.to_int b)
+let exp_of_linksem =
+  let rec value_of_linksem = function
+  | Elf_symbolic.Section s -> Section s
+  | Elf_symbolic.Const x -> Const (Z.to_int x)
+  | Elf_symbolic.BinOp (x, op, y) -> BinOp (value_of_linksem x, op, value_of_linksem y)
+  | Elf_symbolic.UnOp (op, x) -> UnOp (op, value_of_linksem x)
+  | Elf_symbolic.AssertRange (_, _, _) -> Raise.fail "AssertRange should not occur in value expression"
+  | Elf_symbolic.Mask (_, _, _) -> Raise.fail "AssertRange should not occur in value expression"
+  in function
+  | Elf_symbolic.Mask (e, hi, lo) ->
+      let e, range = match e with
+      | Elf_symbolic.AssertRange (e, min, max) -> e, Some (Z.to_int64 min, Z.to_int64 max)
+      | e -> e, None
+      in
+      fun target -> {target; range; mask = (Z.to_int hi, Z.to_int lo); value = value_of_linksem e}
+  | _ -> Raise.fail "Expression does not have Mask in top level"
+
 
 let of_linksem: linksem_t -> t = function
 | LinksemRelocatable.AArch64 relocs ->
     let add k Elf_symbolic.{ arel_value; arel_target } m =
-      IMap.add (Z.to_int k) { value = exp_of_linksem arel_value; target = AArch64 arel_target } m
+      IMap.add (Z.to_int k) (exp_of_linksem arel_value (AArch64 arel_target)) m
     in
     Pmap.fold add relocs IMap.empty
 
@@ -53,7 +65,6 @@ let rec pp_exp = Pp.(
   | BinOp (a, Sub, b) -> !^"(" ^^ pp_exp a ^^ !^"-" ^^ pp_exp b ^^ !^")"
   | BinOp (a, And, b) -> !^"(" ^^ pp_exp a ^^ !^"&" ^^ pp_exp b ^^ !^")"
   | UnOp (Not, b) -> !^"(" ^^ !^"~" ^^ pp_exp b ^^ !^")"
-  | Mask (x, a, b) -> pp_exp x ^^ !^"[" ^^ int a ^^ !^":" ^^ int b ^^ !^"]"
 )
 
 let pp_target = Pp.(function
@@ -65,7 +76,8 @@ let pp_target = Pp.(function
 | AArch64 Abi_aarch64_symbolic_relocation.LDST -> !^"LDST")
 
 let pp_rel rel =
-  Pp.(pp_target rel.target ^^ !^": " ^^ pp_exp rel.value)
+  let hi, lo = rel.mask in
+  Pp.(pp_target rel.target ^^ !^": " ^^ pp_exp rel.value ^^ !^"[" ^^ int hi ^^ !^":" ^^ int lo ^^ !^"]")
 
 let pp rels =
   if IMap.is_empty rels then
diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index 98d7dfa2..e5c95d72 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -79,6 +79,25 @@ type config = Server.config
 module Opcode (*: Cache.Key *) = struct
   type t = Server.opcode option
 
+  let reloc_id: Relocation.t option -> int = function
+  | None -> 0
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640) -> 1
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320) -> 2
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP) -> 3
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD) -> 4
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST) -> 5
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 6
+
+  let reloc_of_id: int -> Relocation.t option = function
+  | 0 -> None
+  | 1 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640)
+  | 2 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320)
+  | 3 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP)
+  | 4 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD)
+  | 5 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST)
+  | 6 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL)
+  | _ -> Raise.fail "invalid reloc id"
+
   let equal a b =
     match (a, b) with
     | (None, None) -> true
@@ -93,7 +112,7 @@ module Opcode (*: Cache.Key *) = struct
     | Some (bs, rel) ->
         let i = BytesSeq.getintle_ze bs 0 in
         let l = BytesSeq.length bs in
-        let rel_id = Server.reloc_id rel in
+        let rel_id = reloc_id rel in
         if small_enough bs rel_id then begin
           assert (not @@ IntBits.get i IntBits.back);
           let res = IntBits.blit l 0 i (IntBits.back - 3) 3 in
@@ -105,7 +124,7 @@ module Opcode (*: Cache.Key *) = struct
   let to_file _file = function
     | None -> ()
     | Some (bs, rel) ->
-        let rel_id = Server.reloc_id rel in
+        let rel_id = reloc_id rel in
         if small_enough bs rel_id then ()
         else
           Raise.todo()
@@ -120,7 +139,7 @@ module Opcode (*: Cache.Key *) = struct
       let size = IntBits.sub hash (IntBits.back - 3) 3 in
       let b = Bytes.create size in
       Bits.unsafe_blit_of_int data 0 b 0 (size * 8);
-      Some (BytesSeq.of_bytes b, Server.reloc_of_id reloc_id)
+      Some (BytesSeq.of_bytes b, reloc_of_id reloc_id)
 end
 
 (** Representation of trace lists on disk.
diff --git a/src/isla/isla.ml b/src/isla/isla.ml
index 5ed4bdf5..e61981e1 100644
--- a/src/isla/isla.ml
+++ b/src/isla/isla.ml
@@ -50,6 +50,7 @@ module Cache = Cache
 module Conv = Conv
 module Manip = Manip
 module Preprocess = Preprocess
+module Relocation = Relocation
 module Run = Run
 module Server = Server
 module Test = Test
diff --git a/src/isla/relocation.ml b/src/isla/relocation.ml
new file mode 100644
index 00000000..21f7c268
--- /dev/null
+++ b/src/isla/relocation.ml
@@ -0,0 +1,44 @@
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
+type t = Elf.Relocations.target
+
+type segment = string * (int * int) (* mapping the name of a segment to the range of the relocation value *)
+
+let pp_opcode_with_segments (b, r) =
+  match r with
+  | None -> Pp.(!^"#x" ^^ BytesSeq.ppint b)
+  | Some (Elf.Relocations.AArch64 rtype) ->
+      let bits = BytesSeq.getbvle ~size:32 b 0 in
+      Pp.(
+        match rtype with
+        | Abi_aarch64_symbolic_relocation.Data640 -> fatal "Data64 relocation not allowed for instruction"
+        | Abi_aarch64_symbolic_relocation.Data320 -> fatal "Data32 relocation not allowed for instruction"
+        | Abi_aarch64_symbolic_relocation.ADRP -> 
+            BitVec.pp_smt (BitVec.extract 31 31 bits)  
+            ^^ !^" x0:2 " ^^
+            BitVec.pp_smt (BitVec.extract 24 28 bits)
+            ^^ !^" x1:19 " ^^
+            BitVec.pp_smt (BitVec.extract 0 4 bits)
+        | Abi_aarch64_symbolic_relocation.ADD -> 
+            BitVec.pp_smt (BitVec.extract 22 31 bits)  
+            ^^ !^" x0:12 " ^^
+            BitVec.pp_smt (BitVec.extract 0 9 bits)
+        | Abi_aarch64_symbolic_relocation.LDST -> (* TODO different width loads, alignment *) 
+            BitVec.pp_smt (BitVec.extract 22 31 bits)  
+            ^^ !^" x0:10 " ^^
+            BitVec.pp_smt (BitVec.extract 0 11 bits)
+        | Abi_aarch64_symbolic_relocation.CALL -> 
+            BitVec.pp_smt (BitVec.extract 26 31 bits)  
+            ^^ !^" x0:26 "
+      )
+
+(* for interpreting the segments *)
+let segments_of_reloc: t -> segment list = function
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640 -> fatal "invalid relocation for instructions (Data64)"
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320 -> fatal "invalid relocation for instructions (Data32)"
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP -> ["x0", (0, 1); "x1", (2, 20)] (* or absolute? ["x0", (12, 13); "x1", (14, 32)] *)
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD -> ["x0", (0, 11)]
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST -> ["x0", (0, 9)] (* TODO depends on load size *) (* or absolute? ["x0", (2, 11)] *)
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL -> ["x0", (0, 25)] (* or absolute? ["x0", (2, 27)] *)
\ No newline at end of file
diff --git a/src/isla/server.ml b/src/isla/server.ml
index b2ba008b..e6f247ff 100644
--- a/src/isla/server.ml
+++ b/src/isla/server.ml
@@ -68,30 +68,8 @@ type config = Config.t
     processor exception/fault) or not *)
 type trcs = Base.instruction_segments option * (bool * Base.rtrc) list
 
-type reloc = Elf.Relocations.target
-
-let reloc_id: reloc option -> int = function
-| None -> 0
-| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640) -> 1
-| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320) -> 2
-| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP) -> 3
-| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD) -> 4
-| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST) -> 5
-| Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 6
-
-let reloc_of_id: int -> reloc option = function
-| 0 -> None
-| 1 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640)
-| 2 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320)
-| 3 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP)
-| 4 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD)
-| 5 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST)
-| 6 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL)
-| _ -> Raise.fail "invalid reloc id"
-
-type opcode = BytesSeq.t * reloc option
-
-type reloc_segment = string * (int * int) (* mapping the name of a segment to the range of the relocation value *)
+type opcode = BytesSeq.t * Relocation.t option
+
 
 (** Bump when updating isla.
     TODO: move the version checking to allow a range of version.
@@ -228,48 +206,11 @@ let pp_answer = function
 (** The type of a request to isla *)
 type request = TEXT_ASM of string | ASM of opcode | VERSION | STOP
 
-let pp_interpreted_opcode (b, r) =
-  match r with
-  | None -> Pp.(!^"#x" ^^ BytesSeq.ppint b)
-  | Some (Elf.Relocations.AArch64 rtype) ->
-      let bits = BytesSeq.getbvle ~size:32 b 0 in
-      Pp.(
-        match rtype with
-        | Abi_aarch64_symbolic_relocation.Data640 -> fatal "Data64 relocation not allowed for instruction"
-        | Abi_aarch64_symbolic_relocation.Data320 -> fatal "Data32 relocation not allowed for instruction"
-        | Abi_aarch64_symbolic_relocation.ADRP -> 
-            BitVec.pp_smt (BitVec.extract 31 31 bits)  
-            ^^ !^" x0:2 " ^^
-            BitVec.pp_smt (BitVec.extract 24 28 bits)
-            ^^ !^" x1:19 " ^^
-            BitVec.pp_smt (BitVec.extract 0 4 bits)
-        | Abi_aarch64_symbolic_relocation.ADD -> 
-            BitVec.pp_smt (BitVec.extract 22 31 bits)  
-            ^^ !^" x0:12 " ^^
-            BitVec.pp_smt (BitVec.extract 0 9 bits)
-        | Abi_aarch64_symbolic_relocation.LDST -> (* TODO different width loads, alignment *) 
-            BitVec.pp_smt (BitVec.extract 22 31 bits)  
-            ^^ !^" x0:10 " ^^
-            BitVec.pp_smt (BitVec.extract 0 11 bits)
-        | Abi_aarch64_symbolic_relocation.CALL -> 
-            BitVec.pp_smt (BitVec.extract 26 31 bits)  
-            ^^ !^" x0:26 "
-      )
-
-(* for interpreting the segments *)
-let segments_of_reloc: reloc -> reloc_segment list = function
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640 -> fatal "invalid relocation for instructions (Data64)"
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320 -> fatal "invalid relocation for instructions (Data32)"
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP -> ["x0", (0, 1); "x1", (2, 20)] (* or absolute? ["x0", (12, 13); "x1", (14, 32)] *)
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD -> ["x0", (0, 11)]
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST -> ["x0", (0, 9)] (* TODO depends on load size *) (* or absolute? ["x0", (2, 11)] *)
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL -> ["x0", (0, 25)] (* or absolute? ["x0", (2, 27)] *)
-
 (** Convert a request into the string message expected by isla-client
     This should match the protocol *)
 let string_of_request = function
   | TEXT_ASM s -> Printf.sprintf "execute_asm %s" s
-  | ASM b -> Pp.(sprintc @@ !^"execute " ^^ pp_interpreted_opcode b)
+  | ASM b -> Pp.(sprintc @@ !^"execute " ^^ Relocation.pp_opcode_with_segments b)
   | VERSION -> "version"
   | STOP -> "stop"
 
diff --git a/src/run/runner.ml b/src/run/runner.ml
index fda103e4..7ae5ff59 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -165,13 +165,13 @@ let fetch (runner : t) (pc : Elf.Address.t) : slot =
 let execute_normal ?(prelock = ignore) ~pc runner (instr : Trace.Instr.t) state =
   let dwarf = runner.dwarf in
   let next = instr.length in
-  let segments_map = instr.segments in
+  let relocation = instr.relocation in
   let run_pure () =
     List.map
       (fun (trc : Trace.Instr.trace_meta) ->
         let nstate = State.copy state in
         State.set_last_pc nstate pc;
-        Trace.Run.trace_pc_mut ?dwarf ~segments_map ~next nstate trc.trace;
+        Trace.Run.trace_pc_mut ?dwarf ?relocation ~next nstate trc.trace;
         nstate)
       instr.traces
   in
@@ -179,7 +179,7 @@ let execute_normal ?(prelock = ignore) ~pc runner (instr : Trace.Instr.t) state
     match instr.traces with
     | [trc] ->
         State.set_last_pc state pc;
-        Trace.Run.trace_pc_mut ?dwarf ~segments_map ~next state trc.trace;
+        Trace.Run.trace_pc_mut ?dwarf ?relocation ~next state trc.trace;
         [state]
     | _ ->
         prelock state;
@@ -193,7 +193,7 @@ let skip runner state : State.t list =
   try
     let pc = State.Exp.expect_sym_address pc_exp in
     match fetch runner pc with
-    | Normal { traces = _; read = _; written = _; length; opcode = _; segments = _ }
+    | Normal { traces = _; read = _; written = _; length; opcode = _; relocation = _ }
      |Special length
      |IslaFail length ->
         let state = State.copy_if_locked state in
diff --git a/src/trace/context.ml b/src/trace/context.ml
index 3ed8317d..d03b0732 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -48,6 +48,10 @@
     should be added here
 *)
 
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
 module SMap = Map.Make (String)
 
 (** The context to run a trace *)
@@ -59,21 +63,43 @@ type t = {
   dwarf : Dw.t option;  (** Optionally DWARF information. If present, typing is enabled *)
 }
 
-let rec exp_of_relocation: Elf.Relocations.exp -> State.exp = 
-  let f = exp_of_relocation in function
+let rec exp_of_relocation_exp: Elf.Relocations.exp -> State.exp = 
+  let f = exp_of_relocation_exp in function
   | Section s -> State.Exp.of_var (State.Var.Section s) (* TODO put the actual value there, size? *)
   | Const x -> Exp.Typed.bits (BitVec.of_int x ~size:64) (* TODO size? *)
   | BinOp (a, Add, b) -> Exp.Typed.(f a + f b)
   | BinOp (a, Sub, b) -> Exp.Typed.(f a - f b)
   | BinOp (a, And, b) -> Exp.Typed.manyop (AstGen.Ott.Bvmanyarith AstGen.Ott.Bvand) [f a; f b]
   | UnOp (Not, b) -> Exp.Typed.unop AstGen.Ott.Bvnot (f b)
-  | Mask (x, last, first) -> Exp.Typed.extract ~last ~first (f x)
+  (* | Mask (x, last, first) -> Exp.Typed.extract ~last ~first (f x) *)
 
 (** Build a {!context} from a state *)
-let make_context ?dwarf ?segments_map state =
+let make_context ?dwarf ?relocation state =
   let reg_writes = Vec.empty () in
   let mem_reads = HashVector.empty () in
-  let segments = segments_map |> Option.value ~default:SMap.empty |> SMap.map exp_of_relocation in
+
+  let segments = relocation
+    |> Option.map (fun relocation ->
+      let open Elf.Relocations in
+      let value = exp_of_relocation_exp relocation.value in
+      Option.iter (fun (min, max) ->
+          let min = Exp.Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 min in
+          let max = Exp.Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 max in
+          let cond1 = Exp.Typed.(binop (Bvcomp Bvsle) min value) in
+          let cond2 = Exp.Typed.(binop (Bvcomp Bvslt) value max) in
+          let cond = Exp.Typed.(manyop And [cond1; cond2]) in
+          State.push_assert state cond;
+      ) relocation.range;
+      let (last, first) = relocation.mask in
+      let masked = Exp.Typed.extract ~first ~last value in
+
+      relocation.target
+      |> Isla.Relocation.segments_of_reloc
+      |> SMap.of_list
+      |> SMap.map (fun (first, last) -> Exp.Typed.extract ~first ~last masked)
+    )
+    |> Option.value ~default:SMap.empty
+  in
   { state; reg_writes; mem_reads; dwarf; segments }
 
 (** Expand a Trace variable to a State expression, using the context *)
diff --git a/src/trace/instr.ml b/src/trace/instr.ml
index 012273a5..e53848b1 100644
--- a/src/trace/instr.ml
+++ b/src/trace/instr.ml
@@ -69,7 +69,7 @@ type t = {
   read : Reg.t list;
   written : Reg.t list;
   opcode : BytesSeq.t;
-  segments: Elf.Relocations.exp SMap.t
+  relocation : Elf.Relocations.rel option;
 }
 
 let dedup_regs = List.sort_uniq State.Reg.compare
@@ -102,31 +102,18 @@ let trace_meta_of_trace trace =
   { trace; jump_target = !jump; read = dedup_regs !read; written = dedup_regs !written }
 
 (** Generate full instruction data from a list of traces *)
-let of_traces (opcode: BytesSeq.t * Elf.Relocations.rel option) traces =
+let of_traces ((opcode: BytesSeq.t), (relocation: Elf.Relocations.rel option)) traces =
   let traces = List.map trace_meta_of_trace traces in
-  let opcode, reloc = opcode in
   let length = BytesSeq.length opcode in
   let read = dedup_regs @@ List.concat_map (fun (tr : trace_meta) -> tr.read) traces in
   let written = dedup_regs @@ List.concat_map (fun (tr : trace_meta) -> tr.written) traces in
 
-  let segments = match reloc with
-  | None -> SMap.empty
-  | Some reloc ->
-      reloc.target
-      |> Isla.Server.segments_of_reloc
-      |> List.map (fun (v, (lo, hi)) -> (v, Elf.Relocations.Mask(reloc.value, hi, lo)))
-      |> SMap.of_list
-  in
-  { traces; length; read; written; opcode; segments }
+  { traces; length; read; written; opcode; relocation }
 
 (** Pretty print the representation of an instruction *)
 let pp instr =
   let open Pp in
-  (prefix 4 1 !^"Segments:" @@
-    separate_map hardline
-      (pair string Elf.Relocations.pp_exp)
-      (SMap.to_list instr.segments))
-  ^^ hardline ^^
+  !^"Relocation" ^^ optional Elf.Relocations.pp_rel instr.relocation ^^ hardline ^^
   separate_mapi hardline
     (fun i trc -> prefix 4 1 (dprintf "Trace %d:" i) (Base.pp trc.trace))
     instr.traces
diff --git a/src/trace/run.ml b/src/trace/run.ml
index df944ca7..45c9252d 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -114,17 +114,17 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
   | Assert exp -> State.push_assert ctxt.state (expand ~ctxt exp)
 
 (** Run a trace on the provided state by mutation. Enable typing if [dwarf] is provided *)
-let trace_mut ?dwarf ?segments_map (state : State.t) (events : Base.t) : unit =
+let trace_mut ?dwarf ?relocation (state : State.t) (events : Base.t) : unit =
   assert (not @@ State.is_locked state);
   info "Running trace with typing %s" (if dwarf <> None then "on" else "off");
-  let ctxt = Context.make_context ?dwarf ?segments_map state in
+  let ctxt = Context.make_context ?dwarf ?relocation state in
   List.iter (event_mut ~ctxt) events;
   Vec.iter (fun (reg, tval) -> State.Reg.Map.set state.regs reg tval) ctxt.reg_writes
 
 (** Run a trace on the provided state by returning an updated copy.*)
-let trace ?dwarf ?segments_map (start : State.t) (events : Base.t) : State.t =
+let trace ?dwarf ?relocation (start : State.t) (events : Base.t) : State.t =
   let state = State.copy start in
-  trace_mut ?dwarf ?segments_map state events;
+  trace_mut ?dwarf ?relocation state events;
   State.lock state;
   state
 
@@ -133,12 +133,12 @@ let trace ?dwarf ?segments_map (start : State.t) (events : Base.t) : State.t =
 
     Thus this function automatically handle moving the PC for fall-through instruction
 *)
-let trace_pc_mut ?dwarf ?segments_map ~(next : int) (state : State.t) (events : Base.t) : unit =
+let trace_pc_mut ?dwarf ?relocation ~(next : int) (state : State.t) (events : Base.t) : unit =
   let pc = Arch.pc () in
   let rec is_touching_pc : Base.t -> bool = function
     | [] -> false
     | WriteReg { reg; _ } :: _ when reg = pc -> true
     | _ :: l -> is_touching_pc l
   in
-  trace_mut ?dwarf ?segments_map state events;
+  trace_mut ?dwarf ?relocation state events;
   if is_touching_pc events then State.concretize_pc ~pc state else State.bump_pc ~pc state next

From 3832eb4c8ff55a6e251c7a29a6239ceeb10328ef Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 15 Jan 2025 22:28:17 +0100
Subject: [PATCH 027/116] todo

---
 notes-TODO | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/notes-TODO b/notes-TODO
index 66ca908d..b1a58b67 100644
--- a/notes-TODO
+++ b/notes-TODO
@@ -2,4 +2,8 @@ Symbolic symbol table
 - value of symbol?? (we don't have segments in relocatable files)
 - can probably keep the same api, but addresses are symbolic
 
-Instruction fetch: is it sound? (rewriting .text)
\ No newline at end of file
+Instruction fetch: is it sound? (rewriting .text)
+
+Z3 finding unique solution
+- Get model -> assert not model -> check now it is unsat
+- Need to extend the protocol probably
\ No newline at end of file

From 83414d1a9df9aacb3579cc3e0675ab1fba5326eb Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 16 Jan 2025 16:55:27 +0100
Subject: [PATCH 028/116] Smarter context full simplifier

---
 src/ast/manip.ml     |  7 ++++
 src/bin/main.ml      |  1 +
 src/bin/readDwarf.ml |  1 +
 src/z3/z3.ml         | 76 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 85 insertions(+)

diff --git a/src/ast/manip.ml b/src/ast/manip.ml
index 46a7ce9c..b21dffe7 100644
--- a/src/ast/manip.ml
+++ b/src/ast/manip.ml
@@ -350,3 +350,10 @@ let check_no_mem (e : ('a, 'v, 'b, 'm) exp) : bool =
 let expect_no_mem ?(handler = fun () -> failwith "Expected no mem") :
     ('a, 'v, 'b, 'm1) exp -> ('a, 'v, 'b, 'm2) exp =
  fun exp -> if check_no_mem exp then Obj.magic exp else handler ()
+
+
+let all_subterms e =
+  let rec recurse acc e =
+    e :: direct_exp_fold_left_exp recurse acc e
+  in
+  direct_exp_fold_left_exp recurse [] e
\ No newline at end of file
diff --git a/src/bin/main.ml b/src/bin/main.ml
index 714c0fc2..132b8f4a 100644
--- a/src/bin/main.ml
+++ b/src/bin/main.ml
@@ -74,6 +74,7 @@ let commands =
     (* Run.FuncRD.command; *)
     Other_cmds.CopySourcesCmd.command;
     (* BranchTable.command; *)
+    Z3.Test.command;
   ]
 
 let _ = Printexc.record_backtrace Config.enable_backtrace
diff --git a/src/bin/readDwarf.ml b/src/bin/readDwarf.ml
index 957552f8..6be5927f 100644
--- a/src/bin/readDwarf.ml
+++ b/src/bin/readDwarf.ml
@@ -73,6 +73,7 @@ let commands =
     Run.Block.command;
     (* Run.FuncRD.command; *)
     CopySourcesCmd.command;
+    Z3.Test.command;
   ]
 
 let _ = Printexc.record_backtrace Config.enable_backtrace
diff --git a/src/z3/z3.ml b/src/z3/z3.ml
index 45321719..73733720 100644
--- a/src/z3/z3.ml
+++ b/src/z3/z3.ml
@@ -395,6 +395,10 @@ module type S = sig
       This results in two calls to the SMT solver. one with {!check} and one with {!check_sat} *)
   val check_both : server -> exp -> bool option
 
+  val simplify_subterms : server -> exp -> exp
+
+  val simplify_subterms_decl : server -> declared:unit Htbl.t -> exp -> exp
+
   (*****************************************************************************)
   (*****************************************************************************)
   (*****************************************************************************)
@@ -415,6 +419,8 @@ module type S = sig
 
   (** Do a standalone check of whether the set of assertion is sat *)
   val check_sat_full : exp list -> bool option
+
+  val simplify_subterms_full : ?hyps:exp list -> exp -> exp
 end
 
 module SimpContext = ContextCounter (struct
@@ -516,4 +522,74 @@ module Make (Var : Var) : S with type var = Var.t = struct
     | _ -> (
         match check_sat serv e with Some false as f -> f | _ -> None
       )
+
+  
+  let rec simplify_subterms serv (e : Exp.t) : Exp.t =
+    e |> Ast.Manip.all_subterms
+    |> List.find_opt (fun t ->
+      let et = Typed.get_type e in
+      let tt = Typed.get_type t in
+      Printf.printf "Types: %t, %t\n" Pp.(top Ast.pp_ty (Ast.Manip.ty_allow_mem et)) Pp.(top Ast.pp_ty (Ast.Manip.ty_allow_mem tt));
+      Typed.get_type e = Typed.get_type t &&
+      let result = check serv Typed.(e = t) in
+      Printf.printf "%t\n" Pp.(top (optional bool) result);
+      result = Some true
+    )
+    |> Option.map (simplify_subterms serv)
+    |> Option.value_fun ~default:(fun () ->
+      Ast.Manip.direct_exp_map_exp (simplify_subterms serv) e
+    )
+  
+  let simplify_subterms_decl serv ~declared (e : Exp.t) : Exp.t =
+    declare_vars serv ~declared e;
+    simplify_subterms serv e
+
+  let simplify_subterms_full ?(hyps = []) e =
+    let serv = ensure_started_get () in
+    SimpContext.openc ();
+    let declared = Htbl.create 10 in
+    List.iter (send_assert_decl ~declared serv) hyps;
+    let res = simplify_subterms_decl ~declared serv e in
+    SimpContext.closec ();
+    res
+end
+
+module Test = struct
+  module Var = struct
+    include String
+    
+    let pp = Pp.string
+
+    let ty _ = Ast.Ty_BitVec 64
+
+    let of_string = Fun.id
+  end
+
+  module Typed = Exp.Typed
+  module Exp = Exp.Make (Var)
+
+  module Z3Test = Make (Var)
+
+  let test () =
+    let x = Typed.var ~typ:(Ast.Ty_BitVec 64) "x" in
+    let bvint64 = Typed.bits_int ~size:64 in
+    let constr = Typed.(binop (Ast.Bvcomp Ast.Bvult) x (bvint64 16)) in
+    let exp = Typed.(concat [bits_int ~size:60 0; extract x ~first:0 ~last:3]) in
+    let simplified = Z3Test.simplify_subterms_full ~hyps:[constr] exp in
+    Printf.printf "original: %t\n" (Pp.top Exp.pp exp);
+    Printf.printf "simplified: %t\n" (Pp.top Exp.pp simplified);
+
+  
+  open Cmdliner
+  open Config.CommonOpt
+
+  
+  let term = Term.(CmdlinerHelper.func_options (config :: z3 :: comopts) test $ const ())
+
+  let info =
+    let doc = ""
+    in
+    Cmd.(info "z3-test" ~doc ~exits)
+  
+  let command = (term, info)
 end

From 75185eed6e40f7921ed06f66425da84d6d0b05e3 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 16 Jan 2025 18:53:56 +0100
Subject: [PATCH 029/116] Simplify relocated addresses

---
 src/elf/relocations.ml | 20 ++++++++++++++------
 src/state/base.ml      | 13 ++++++++++++-
 src/state/base.mli     |  4 ++++
 src/trace/context.ml   | 15 +++++++++------
 4 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index e9295717..1a60a8bd 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -15,10 +15,14 @@ type exp =
 (* | AssertRange of (exp * int * int) *)
 (* | Mask of (exp * int * int) *)
 
+type assertion =
+| Range of int64 * int64
+| Alignment of int
+
 type rel = {
   target : target;
   value : exp;
-  range: (int64 * int64) option;
+  assertions: assertion list;
   mask : int * int;
 }
 
@@ -33,14 +37,18 @@ let exp_of_linksem =
   | Elf_symbolic.BinOp (x, op, y) -> BinOp (value_of_linksem x, op, value_of_linksem y)
   | Elf_symbolic.UnOp (op, x) -> UnOp (op, value_of_linksem x)
   | Elf_symbolic.AssertRange (_, _, _) -> Raise.fail "AssertRange should not occur in value expression"
+  | Elf_symbolic.AssertAlignment (_, _) -> Raise.fail "AssertAlignment should not occur in value expression"
   | Elf_symbolic.Mask (_, _, _) -> Raise.fail "AssertRange should not occur in value expression"
   in function
   | Elf_symbolic.Mask (e, hi, lo) ->
-      let e, range = match e with
-      | Elf_symbolic.AssertRange (e, min, max) -> e, Some (Z.to_int64 min, Z.to_int64 max)
-      | e -> e, None
-      in
-      fun target -> {target; range; mask = (Z.to_int hi, Z.to_int lo); value = value_of_linksem e}
+      let rec extract_asserts e =
+        match e with
+        | Elf_symbolic.AssertRange (e, min, max) -> let (e, a) = extract_asserts e in e, Range (Z.to_int64 min, Z.to_int64 max) :: a
+        | Elf_symbolic.AssertAlignment (e, bits) -> let (e, a) = extract_asserts e in e, Alignment (Z.to_int bits) :: a
+        | e -> e, []
+        in
+      let e, assertions = extract_asserts e in
+      fun target -> {target; assertions; mask = (Z.to_int hi, Z.to_int lo); value = value_of_linksem e}
   | _ -> Raise.fail "Expression does not have Mask in top level"
 
 
diff --git a/src/state/base.ml b/src/state/base.ml
index 55606fc8..29f6ab80 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -326,6 +326,7 @@ type t = {
   mutable regs : Tval.t Reg.Map.t;  (** The values and types of registers *)
   read_vars : Tval.t Vec.t;  (** The results of reads made since base state *)
   mutable asserts : exp list;  (** Only asserts since base_state *)
+  mutable relocation_asserts : exp list;  (** Only asserts since base_state *)
   mem : Mem.t;
   elf : Elf.File.t option;
       (** Optionally an ELF file, this may be used when running instructions on
@@ -368,6 +369,7 @@ let make ?elf () =
       regs = Reg.Map.init @@ Tval.of_reg id;
       read_vars = Vec.empty ();
       asserts = [];
+      relocation_asserts = [];
       mem = Mem.empty ();
       elf;
       fenv = Fragment.Env.make ();
@@ -389,6 +391,7 @@ let copy ?elf state =
       regs = Reg.Map.copy state.regs;
       read_vars = Vec.empty ();
       asserts = (if locked then [] else state.asserts);
+      relocation_asserts = (if locked then [] else state.relocation_asserts);
       mem = (if locked then Mem.from state.mem else Mem.copy state.mem);
       elf = Option.(elf ||| state.elf);
       fenv = Fragment.Env.copy state.fenv;
@@ -405,6 +408,13 @@ let push_assert (s : t) (e : exp) =
   assert (not @@ is_locked s);
   s.asserts <- e :: s.asserts
 
+let push_relocation_assert (s : t) (e : exp) =
+  assert (not @@ is_locked s);
+  s.relocation_asserts <- e :: s.relocation_asserts
+
+let rec load_relocation_asserts (s : t) =
+  s.relocation_asserts @ (s.base_state |> Option.map load_relocation_asserts |> Option.value ~default:[])
+
 let set_asserts state asserts =
   assert (not @@ is_locked state);
   state.asserts <- asserts
@@ -476,7 +486,8 @@ let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t
   Option.value exp ~default:(Exp.of_var var)
 
 let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
-  (* let addr = Z3St.simplify_full addr in *)
+  let hyps = load_relocation_asserts s in
+  let addr = Z3St.simplify_subterms_full ~hyps addr in
   let sym, conc = Sums.split_concrete addr in
   debug "Address: %t + %t" Pp.(top (optional Exp.pp) sym) Pp.(top BitVec.pp_smt conc);
   if ConcreteEval.is_concrete addr || Vec.length s.mem.frags = 0 then
diff --git a/src/state/base.mli b/src/state/base.mli
index bcba6c5f..f4945039 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -288,6 +288,7 @@ type t = private {
   mutable regs : Tval.t Reg.Map.t;  (** The values and types of registers *)
   read_vars : Tval.t Vec.t;  (** The results of reads made since base state *)
   mutable asserts : exp list;  (** Only asserts since base_state *)
+  mutable relocation_asserts : exp list;  (** Only asserts since base_state *)
   mem : Mem.t;
   elf : Elf.File.t option;
       (** Optionally an ELF file, this may be used when running instructions on
@@ -390,6 +391,9 @@ val copy_if_locked : ?elf:Elf.File.t -> t -> t
 (** Add an assertion to a state *)
 val push_assert : t -> exp -> unit
 
+(** Add an assertion to a state *)
+val push_relocation_assert : t -> exp -> unit
+
 (** Set a state to be impossible (single [false] assert). *)
 val set_impossible : t -> unit
 
diff --git a/src/trace/context.ml b/src/trace/context.ml
index d03b0732..1734f041 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -82,22 +82,25 @@ let make_context ?dwarf ?relocation state =
     |> Option.map (fun relocation ->
       let open Elf.Relocations in
       let value = exp_of_relocation_exp relocation.value in
-      Option.iter (fun (min, max) ->
+      List.iter (function
+        | Range (min, max) ->
           let min = Exp.Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 min in
           let max = Exp.Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 max in
           let cond1 = Exp.Typed.(binop (Bvcomp Bvsle) min value) in
           let cond2 = Exp.Typed.(binop (Bvcomp Bvslt) value max) in
-          let cond = Exp.Typed.(manyop And [cond1; cond2]) in
-          State.push_assert state cond;
-      ) relocation.range;
+          State.push_relocation_assert state Exp.Typed.(manyop And [cond1; cond2])
+        | Alignment b ->
+          let last = b-1 in
+          State.push_relocation_assert state Exp.Typed.(extract ~first:0 ~last value = bits_int ~size:b 0)
+      ) relocation.assertions;
       let (last, first) = relocation.mask in
       let masked = Exp.Typed.extract ~first ~last value in
-
+      
       relocation.target
       |> Isla.Relocation.segments_of_reloc
       |> SMap.of_list
       |> SMap.map (fun (first, last) -> Exp.Typed.extract ~first ~last masked)
-    )
+      )
     |> Option.value ~default:SMap.empty
   in
   { state; reg_writes; mem_reads; dwarf; segments }

From ad13b155bf14026cd8d1da92e7b67339833f533e Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 17 Jan 2025 16:15:45 +0100
Subject: [PATCH 030/116] Fix immediate encoding

---
 src/isla/relocation.ml | 4 ++--
 src/state/base.ml      | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/isla/relocation.ml b/src/isla/relocation.ml
index 21f7c268..3e3004ad 100644
--- a/src/isla/relocation.ml
+++ b/src/isla/relocation.ml
@@ -26,9 +26,9 @@ let pp_opcode_with_segments (b, r) =
             ^^ !^" x0:12 " ^^
             BitVec.pp_smt (BitVec.extract 0 9 bits)
         | Abi_aarch64_symbolic_relocation.LDST -> (* TODO different width loads, alignment *) 
-            BitVec.pp_smt (BitVec.extract 22 31 bits)  
+            BitVec.pp_smt (BitVec.extract 20 31 bits)  
             ^^ !^" x0:10 " ^^
-            BitVec.pp_smt (BitVec.extract 0 11 bits)
+            BitVec.pp_smt (BitVec.extract 0 9 bits)
         | Abi_aarch64_symbolic_relocation.CALL -> 
             BitVec.pp_smt (BitVec.extract 26 31 bits)  
             ^^ !^" x0:26 "
diff --git a/src/state/base.ml b/src/state/base.ml
index 29f6ab80..cfcef658 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -488,6 +488,7 @@ let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t
 let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
   let hyps = load_relocation_asserts s in
   let addr = Z3St.simplify_subterms_full ~hyps addr in
+  let addr = Z3St.simplify_full addr in
   let sym, conc = Sums.split_concrete addr in
   debug "Address: %t + %t" Pp.(top (optional Exp.pp) sym) Pp.(top BitVec.pp_smt conc);
   if ConcreteEval.is_concrete addr || Vec.length s.mem.frags = 0 then

From 17424037276df13a5aedcc40c23ee9810bc5e1f6 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 17 Jan 2025 19:05:06 +0100
Subject: [PATCH 031/116] Write with section offset

---
 src/state/base.ml | 46 ++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 38 insertions(+), 8 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index cfcef658..be7d6474 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -485,15 +485,45 @@ let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t
   Option.iter (set_read s (Var.expect_readvar var)) exp;
   Option.value exp ~default:(Exp.of_var var)
 
-let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+let address_to_exp ~(size : int) (addr : Elf.Address.t) =
+  let first = 0 in
+  let last = size - 1 in
+  Typed.(
+    extract ~last ~first
+      (Exp.of_var @@ Var.Section addr.section)
+    +
+    bits_int ~size addr.offset
+  )
+
+let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
+  let ctxt0 = function Var.Section _ -> Value.bv @@ BitVec.of_int ~size:64 0 | _ -> raise ConcreteEval.Symbolic in
+  let offset = addr |> ConcreteEval.eval ~ctxt:ctxt0 |> Value.expect_bv |> BitVec.to_int in
+  let sections = Hashtbl.create 10 in
+  Ast.Manip.exp_iter_var (function Var.Section s -> Hashtbl.add sections s () | _ -> ()) addr;
+
   let hyps = load_relocation_asserts s in
-  let addr = Z3St.simplify_subterms_full ~hyps addr in
-  let addr = Z3St.simplify_full addr in
-  let sym, conc = Sums.split_concrete addr in
-  debug "Address: %t + %t" Pp.(top (optional Exp.pp) sym) Pp.(top BitVec.pp_smt conc);
-  if ConcreteEval.is_concrete addr || Vec.length s.mem.frags = 0 then
-    read ~provenance:Ctype.Main ?ctyp s ~addr ~size
-  else Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
+  let size = addr |> Typed.get_type |> Typed.expect_bv in
+  sections |> Hashtbl.to_seq_keys |> Seq.find_map (fun section ->
+    let address = Elf.Address.{ section; offset } in
+    let expression = address_to_exp ~size address in
+    if Z3St.check_full ~hyps Typed.(expression = addr) = Some true then
+      Some address
+    else
+      None
+  )
+  
+
+let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+  let elf_addr = eval_address s addr in
+  debug "Address: %t" Pp.(top (optional Elf.Address.pp) elf_addr);
+  match elf_addr with
+  | Some elf_addr ->
+      let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
+      let addr = address_to_exp ~size:addr_size elf_addr in
+      read ~provenance:Ctype.Main ?ctyp s ~addr ~size
+  | None when Vec.length s.mem.frags = 0 ->
+      read ~provenance:Ctype.Main ?ctyp s ~addr ~size
+  | None -> Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
 
 let write ~provenance (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) : unit =
   assert (not @@ is_locked s);

From f3468d476bcb286c01421117508073a9ce8974bd Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 17 Jan 2025 19:19:19 +0100
Subject: [PATCH 032/116] Fix type of pc values in state tree

---
 src/run/block_lib.ml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/run/block_lib.ml b/src/run/block_lib.ml
index 2d548c75..3082c0c1 100644
--- a/src/run/block_lib.ml
+++ b/src/run/block_lib.ml
@@ -67,14 +67,14 @@ type label =
   | Start  (** Root node of the tree *)
   | End of string
       (** Lead node of the tree, the string describe which end condition has be triggered *)
-  | BranchAt of int  (** A Branching node at a given PC *)
-  | NormalAt of int  (** A normal instruction at PC. Exists only if [every_instruction] is true *)
+  | BranchAt of Elf.Address.t  (** A Branching node at a given PC *)
+  | NormalAt of Elf.Address.t  (** A normal instruction at PC. Exists only if [every_instruction] is true *)
 
 let label_to_string = function
   | Start -> "Start"
   | End s -> Printf.sprintf "End (%s)" s
-  | BranchAt pc -> Printf.sprintf "Branch at 0x%x" pc
-  | NormalAt pc -> Printf.sprintf "Normal at 0x%x" pc
+  | BranchAt pc -> Printf.sprintf "Branch at %t" Pp.(tos Elf.Address.pp pc)
+  | NormalAt pc -> Printf.sprintf "Normal at %t" Pp.(tos Elf.Address.pp pc)
 
 let pp_label label = label |> label_to_string |> Pp.string
 
@@ -123,11 +123,11 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
           | [state] when not every_instruction -> run_from state
           | [nstate] when every_instruction ->
               let rest = [run_from nstate] in
-              { state; data = NormalAt (pc_exp |> Ast.expect_bits |> BitVec.to_int); rest }
+              { state; data = NormalAt (State.Exp.expect_sym_address pc_exp); rest }
           | states ->
               let rest = List.map run_from states in
               State.Tree.
-                { state; data = BranchAt (pc_exp |> Ast.expect_bits |> BitVec.to_int); rest }
+                { state; data = BranchAt (State.Exp.expect_sym_address pc_exp); rest }
         )
     else begin
       info "Reached dead code at %t" (Pp.top State.Exp.pp pc_exp);
@@ -162,7 +162,7 @@ let gen_endpred ?min ?max ?loop ?(brks = []) () : State.exp -> string option =
     ( try
       Some (State.Exp.expect_sym_address pc_exp)
     with
-      _ -> None
+      _ -> debug "PC is sus"; None
     ) |> Option.map (fun pc ->
       debug "enpred: Evaluating PC %t" (Pp.top Elf.Address.pp pc);
       match (min, max, loop) with

From 8d417e6f6e3a2d5bcd7f217fd92ec6948fac8ace Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 17 Jan 2025 19:26:03 +0100
Subject: [PATCH 033/116] Symbolic write

---
 src/state/base.ml | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index be7d6474..480b06d7 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -530,9 +530,16 @@ let write ~provenance (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.
   Mem.write ~provenance s.mem ~addr ~size ~exp:value
 
 let write_noprov (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) : unit =
-  if ConcreteEval.is_concrete addr || Vec.length s.mem.frags = 0 then
-    write ~provenance:Ctype.Main s ~addr ~size value
-  else Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
+  let elf_addr = eval_address s addr in
+  debug "Address: %t" Pp.(top (optional Elf.Address.pp) elf_addr);
+  match elf_addr with
+  | Some elf_addr ->
+      let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
+      let addr = address_to_exp ~size:addr_size elf_addr in
+      write ~provenance:Ctype.Main s ~addr ~size value
+  | None when Vec.length s.mem.frags = 0 ->
+      write ~provenance:Ctype.Main s ~addr ~size value
+  | None -> Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
 
 let reset_reg (s : t) ?(ctyp : Ctype.t option) (reg : Reg.t) : unit =
   assert (not @@ is_locked s);

From 9cb38f4a94902e472c3004ed2a66d559f7179962 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 20 Jan 2025 18:43:15 +0000
Subject: [PATCH 034/116] Separate fragments for sections

---
 src/run/func.ml    |  2 +-
 src/state/base.ml  | 71 +++++++++++++++++++++++++++++++++++-----------
 src/state/base.mli |  3 ++
 3 files changed, 59 insertions(+), 17 deletions(-)

diff --git a/src/run/func.ml b/src/run/func.ml
index d41d3c03..91167c8b 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -66,7 +66,7 @@ let no_run_prep ~elf:elfname ~name ~entry =
   let abi = Arch.get_abi api in
   Trace.Cache.start @@ Arch.get_isla_config ();
   base "Computing entry state";
-  let start = Init.state () |> State.copy ~elf |> abi.init in
+  let start = Init.state () |> State.copy ~elf |> State.init_sections ~addr_size:Arch.address_size |> abi.init in
   if entry then base "Entry state:\n%t" (Pp.topi State.pp start);
   (dwarf, elf, func, start)
 
diff --git a/src/state/base.ml b/src/state/base.ml
index 480b06d7..542a3f61 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -216,6 +216,18 @@ end
 
 type tval = Tval.t
 
+let section_to_exp ~(size : int) (section : string) =
+  Typed.extract ~last:(size-1) ~first:0
+      (Exp.of_var @@ Var.Section section)
+
+
+let address_to_exp ~(size : int) (addr : Elf.Address.t) =
+  Typed.(
+    section_to_exp ~size addr.section
+    +
+    bits_int ~size addr.offset
+  )
+
 module Mem = struct
   module Size = Ast.Size
 
@@ -231,20 +243,28 @@ module Mem = struct
 
       In general the stack will be the fragment 0 but this is not guaranteed.
       Some execution contexts may even not have any stacks.*)
-  type t = { mutable main : Fragment.t; frags : (Exp.t * Fragment.t) Vec.t }
+  type t = {
+    mutable main : Fragment.t;
+    frags : (Exp.t * Fragment.t) Vec.t;
+    sections : (string, provenance) Hashtbl.t; (* mapping sections to their fragments *)
+  }
 
   (** Get the main fragment of memory *)
-  let get_main { main; frags = _ } = main
+  let get_main { main; frags = _; sections = _ } = main
 
   (** Empty memory, every address is unbound *)
-  let empty () = { main = Fragment.empty; frags = Vec.empty () }
+  let empty () = { main = Fragment.empty; frags = Vec.empty (); sections = Hashtbl.create 10 }
 
   (** Build a new memory from the old one by keeping the old one as a base *)
   let from mem =
-    { main = Fragment.from mem.main; frags = Vec.map (Pair.map Fun.id Fragment.from) mem.frags }
+    { 
+      main = Fragment.from mem.main;
+      frags = Vec.map (Pair.map Fun.id Fragment.from) mem.frags;
+      sections = Hashtbl.copy mem.sections; 
+    }
 
   (** Copy the memory so that it can be mutated separately *)
-  let copy mem = { main = mem.main; frags = Vec.copy mem.frags }
+  let copy mem = { main = mem.main; frags = Vec.copy mem.frags; sections = Hashtbl.copy mem.sections }
 
   (** Add a new fragment with the specified base *)
   let new_frag mem base =
@@ -312,11 +332,28 @@ module Mem = struct
           Vec.ppi
             (fun (base, frag) -> Pp.infix 2 1 colon (Exp.pp base) (Fragment.pp_raw frag))
             mem.frags );
+        ("sections", hashtbl string Ctype.pp_provenance mem.sections)
       ]
 
   (** Check is this memory is empty which means all addresses are undefined *)
   let is_empty mem =
     Fragment.is_empty mem.main && Vec.for_all (Pair.for_all Fun.ctrue Fragment.is_empty) mem.frags
+
+
+  let create_section_frag ~addr_size mem section =
+    match Hashtbl.find_opt mem.sections section with
+    | Some prov -> 
+      info "Fragment for section %s already exists" section;
+      prov
+    | None ->
+      let base = section_to_exp ~size:addr_size section in
+      let prov = new_frag mem base in
+      Hashtbl.replace mem.sections section prov;
+      prov
+  
+  let get_section_provenance mem section =
+    Hashtbl.find_opt mem.sections section
+    |> Option.value ~default:Ctype.Main
 end
 
 type t = {
@@ -404,6 +441,15 @@ let copy ?elf state =
 
 let copy_if_locked ?elf state = if is_locked state then copy ?elf state else state
 
+let init_sections ~addr_size state =
+  let state = copy_if_locked state in
+  let _ = Option.(
+    let+ elf = state.elf in
+    Elf.SymTable.iter elf.symbols @@ fun sym ->
+      let _ = Mem.create_section_frag ~addr_size state.mem sym.addr.section in ()
+  ) in
+  state
+
 let push_assert (s : t) (e : exp) =
   assert (not @@ is_locked s);
   s.asserts <- e :: s.asserts
@@ -485,15 +531,6 @@ let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t
   Option.iter (set_read s (Var.expect_readvar var)) exp;
   Option.value exp ~default:(Exp.of_var var)
 
-let address_to_exp ~(size : int) (addr : Elf.Address.t) =
-  let first = 0 in
-  let last = size - 1 in
-  Typed.(
-    extract ~last ~first
-      (Exp.of_var @@ Var.Section addr.section)
-    +
-    bits_int ~size addr.offset
-  )
 
 let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
   let ctxt0 = function Var.Section _ -> Value.bv @@ BitVec.of_int ~size:64 0 | _ -> raise ConcreteEval.Symbolic in
@@ -520,7 +557,8 @@ let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
   | Some elf_addr ->
       let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
       let addr = address_to_exp ~size:addr_size elf_addr in
-      read ~provenance:Ctype.Main ?ctyp s ~addr ~size
+      let provenance = Mem.get_section_provenance s.mem elf_addr.section in
+      read ~provenance ?ctyp s ~addr ~size
   | None when Vec.length s.mem.frags = 0 ->
       read ~provenance:Ctype.Main ?ctyp s ~addr ~size
   | None -> Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
@@ -536,7 +574,8 @@ let write_noprov (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) :
   | Some elf_addr ->
       let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
       let addr = address_to_exp ~size:addr_size elf_addr in
-      write ~provenance:Ctype.Main s ~addr ~size value
+      let provenance = Mem.get_section_provenance s.mem elf_addr.section in
+      write ~provenance s ~addr ~size value
   | None when Vec.length s.mem.frags = 0 ->
       write ~provenance:Ctype.Main s ~addr ~size value
   | None -> Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
diff --git a/src/state/base.mli b/src/state/base.mli
index f4945039..5e281f57 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -386,6 +386,9 @@ val copy : ?elf:Elf.File.t -> t -> t
     The returned state is always unlocked *)
 val copy_if_locked : ?elf:Elf.File.t -> t -> t
 
+val init_sections : addr_size:int -> t -> t
+
+
 (** {1 State convenience manipulation } *)
 
 (** Add an assertion to a state *)

From 7e10b1d9466a4f98d2f8d9d09a5e3467c7823fa3 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 20 Jan 2025 22:18:51 +0000
Subject: [PATCH 035/116] Initialise symvbols

---
 src/state/base.ml    | 118 ++++++++++++++++++++++++++++++++++---------
 src/state/base.mli   |  16 ++++++
 src/trace/context.ml |  33 ++----------
 3 files changed, 116 insertions(+), 51 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 542a3f61..80a1c2a8 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -183,6 +183,18 @@ module Exp = struct
     in
     let offset = BitVec.to_int conc in
     Elf.Address.{ section; offset }
+  
+  let of_section ~(size : int) (section : string) =
+    Typed.extract ~last:(size-1) ~first:0
+        (of_var @@ Var.Section section)
+
+
+  let of_address ~(size : int) (addr : Elf.Address.t) =
+    Typed.(
+      of_section ~size addr.section
+      +
+      bits_int ~size addr.offset
+    )
 end
 
 type exp = Exp.t
@@ -216,17 +228,71 @@ end
 
 type tval = Tval.t
 
-let section_to_exp ~(size : int) (section : string) =
-  Typed.extract ~last:(size-1) ~first:0
-      (Exp.of_var @@ Var.Section section)
-
+module Relocation = struct
+  type t = {
+    value: Exp.t;
+    asserts: Exp.t list;
+    target: Elf.Relocations.target;
+  }
 
-let address_to_exp ~(size : int) (addr : Elf.Address.t) =
-  Typed.(
-    section_to_exp ~size addr.section
-    +
-    bits_int ~size addr.offset
-  )
+  let rec exp_of_relocation_exp: Elf.Relocations.exp -> exp = 
+    let f = exp_of_relocation_exp in function
+    | Section s -> Exp.of_var (Var.Section s) (* TODO size? *)
+    | Const x -> Typed.bits (BitVec.of_int x ~size:64) (* TODO size? *)
+    | BinOp (a, Add, b) -> Typed.(f a + f b)
+    | BinOp (a, Sub, b) -> Typed.(f a - f b)
+    | BinOp (a, And, b) -> Typed.manyop (AstGen.Ott.Bvmanyarith AstGen.Ott.Bvand) [f a; f b]
+    | UnOp (Not, b) -> Typed.unop AstGen.Ott.Bvnot (f b)
+
+  let of_elf (relocation: Elf.Relocations.rel) = 
+    let open Elf.Relocations in
+    let value = exp_of_relocation_exp relocation.value in
+    let asserts = List.map (function
+      | Range (min, max) ->
+        let min = Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 min in
+        let max = Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 max in
+        let cond1 = Typed.(binop (Bvcomp Bvsle) min value) in
+        let cond2 = Typed.(binop (Bvcomp Bvslt) value max) in
+        Typed.(manyop And [cond1; cond2])
+      | Alignment b ->
+        let last = b-1 in
+        Typed.(extract ~first:0 ~last value = bits_int ~size:b 0)
+    ) relocation.assertions in
+    let (last, first) = relocation.mask in
+    let value = Typed.extract ~first ~last value in
+    { value; asserts; target = relocation.target }
+
+  module IMap = Map.Make (Int)
+
+  let exp_of_data (data : Elf.Symbol.data) =
+    let size = 8 * (BytesSeq.length data.data) in
+    (* Assume little endian here *)
+    let bv = BytesSeq.getbvle ~size data.data 0 in
+    let exp = Typed.bits bv in
+    IMap.fold (fun offset rel (exp, asserts) ->
+      let relocation = of_elf rel in
+      let pos = 8 * offset in
+      let width = match relocation.target with
+      | AArch64 Abi_aarch64_symbolic_relocation.Data640 -> 64
+      | AArch64 Abi_aarch64_symbolic_relocation.Data320 -> 32
+      | _ -> Raise.fail "Unsopported relocation"
+      in
+      let before = if pos > 0 then
+        [Typed.extract ~first:0 ~last:(pos-1) exp]
+      else
+        []
+      in
+      let after = if pos + width < size then
+        [Typed.extract ~first:(pos+width) ~last:(size-1) exp]
+      else
+        []
+      in
+      (
+        Typed.concat (before @ relocation.value :: after),
+        relocation.asserts @ asserts
+      )
+    ) data.relocations (exp, [])
+end
 
 module Mem = struct
   module Size = Ast.Size
@@ -346,7 +412,7 @@ module Mem = struct
       info "Fragment for section %s already exists" section;
       prov
     | None ->
-      let base = section_to_exp ~size:addr_size section in
+      let base = Exp.of_section ~size:addr_size section in
       let prov = new_frag mem base in
       Hashtbl.replace mem.sections section prov;
       prov
@@ -441,15 +507,6 @@ let copy ?elf state =
 
 let copy_if_locked ?elf state = if is_locked state then copy ?elf state else state
 
-let init_sections ~addr_size state =
-  let state = copy_if_locked state in
-  let _ = Option.(
-    let+ elf = state.elf in
-    Elf.SymTable.iter elf.symbols @@ fun sym ->
-      let _ = Mem.create_section_frag ~addr_size state.mem sym.addr.section in ()
-  ) in
-  state
-
 let push_assert (s : t) (e : exp) =
   assert (not @@ is_locked s);
   s.asserts <- e :: s.asserts
@@ -469,6 +526,21 @@ let set_impossible state =
   assert (not @@ is_locked state);
   state.asserts <- [Typed.false_]
 
+let init_sections ~addr_size state =
+  let state = copy_if_locked state in
+  let _ = Option.(
+    let+ elf = state.elf in
+    Elf.SymTable.iter elf.symbols @@ fun sym ->
+      if sym.typ = Elf.Symbol.OBJECT then
+        let provenance = Mem.create_section_frag ~addr_size state.mem sym.addr.section in
+        let addr = Exp.of_address ~size:addr_size sym.addr in
+        let size = Ast.Size.of_bytes sym.size in
+        let (exp, asserts) = Relocation.exp_of_data sym.data in
+        Mem.write ~provenance state.mem ~addr ~size ~exp;
+        List.iter (push_relocation_assert state) asserts;
+  ) in
+  state
+
 let map_mut_exp (f : exp -> exp) s : unit =
   assert (not @@ is_locked s);
   Reg.Map.map_mut_current (Tval.map_exp f) s.regs;
@@ -542,7 +614,7 @@ let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
   let size = addr |> Typed.get_type |> Typed.expect_bv in
   sections |> Hashtbl.to_seq_keys |> Seq.find_map (fun section ->
     let address = Elf.Address.{ section; offset } in
-    let expression = address_to_exp ~size address in
+    let expression = Exp.of_address ~size address in
     if Z3St.check_full ~hyps Typed.(expression = addr) = Some true then
       Some address
     else
@@ -556,7 +628,7 @@ let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
   match elf_addr with
   | Some elf_addr ->
       let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
-      let addr = address_to_exp ~size:addr_size elf_addr in
+      let addr = Exp.of_address ~size:addr_size elf_addr in
       let provenance = Mem.get_section_provenance s.mem elf_addr.section in
       read ~provenance ?ctyp s ~addr ~size
   | None when Vec.length s.mem.frags = 0 ->
@@ -573,7 +645,7 @@ let write_noprov (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) :
   match elf_addr with
   | Some elf_addr ->
       let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
-      let addr = address_to_exp ~size:addr_size elf_addr in
+      let addr = Exp.of_address ~size:addr_size elf_addr in
       let provenance = Mem.get_section_provenance s.mem elf_addr.section in
       write ~provenance s ~addr ~size value
   | None when Vec.length s.mem.frags = 0 ->
diff --git a/src/state/base.mli b/src/state/base.mli
index 5e281f57..665b61a9 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -160,6 +160,10 @@ module Exp : sig
   val of_reg : id -> Reg.t -> t
 
   val expect_sym_address : t -> Elf.Address.t
+
+  val of_section : size:int -> string -> t
+
+  val of_address : size:int -> Elf.Address.t -> t
 end
 
 type exp = Exp.t
@@ -193,6 +197,18 @@ end
 
 type tval = Tval.t
 
+module Relocation : sig
+    type t = {
+        value: Exp.t;
+        asserts: Exp.t list;
+        target: Elf.Relocations.target;
+    }
+
+    val of_elf : Elf.Relocations.rel -> t
+
+    val exp_of_data : Elf.Symbol.data -> (exp * exp list)
+end
+
 (** {1 State memory management } *)
 
 (** This module manages the memory part of the state.
diff --git a/src/trace/context.ml b/src/trace/context.ml
index 1734f041..66a045ee 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -63,16 +63,6 @@ type t = {
   dwarf : Dw.t option;  (** Optionally DWARF information. If present, typing is enabled *)
 }
 
-let rec exp_of_relocation_exp: Elf.Relocations.exp -> State.exp = 
-  let f = exp_of_relocation_exp in function
-  | Section s -> State.Exp.of_var (State.Var.Section s) (* TODO put the actual value there, size? *)
-  | Const x -> Exp.Typed.bits (BitVec.of_int x ~size:64) (* TODO size? *)
-  | BinOp (a, Add, b) -> Exp.Typed.(f a + f b)
-  | BinOp (a, Sub, b) -> Exp.Typed.(f a - f b)
-  | BinOp (a, And, b) -> Exp.Typed.manyop (AstGen.Ott.Bvmanyarith AstGen.Ott.Bvand) [f a; f b]
-  | UnOp (Not, b) -> Exp.Typed.unop AstGen.Ott.Bvnot (f b)
-  (* | Mask (x, last, first) -> Exp.Typed.extract ~last ~first (f x) *)
-
 (** Build a {!context} from a state *)
 let make_context ?dwarf ?relocation state =
   let reg_writes = Vec.empty () in
@@ -80,26 +70,13 @@ let make_context ?dwarf ?relocation state =
 
   let segments = relocation
     |> Option.map (fun relocation ->
-      let open Elf.Relocations in
-      let value = exp_of_relocation_exp relocation.value in
-      List.iter (function
-        | Range (min, max) ->
-          let min = Exp.Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 min in
-          let max = Exp.Typed.bits @@ BitVec.of_z ~size:64 @@ Z.of_int64 max in
-          let cond1 = Exp.Typed.(binop (Bvcomp Bvsle) min value) in
-          let cond2 = Exp.Typed.(binop (Bvcomp Bvslt) value max) in
-          State.push_relocation_assert state Exp.Typed.(manyop And [cond1; cond2])
-        | Alignment b ->
-          let last = b-1 in
-          State.push_relocation_assert state Exp.Typed.(extract ~first:0 ~last value = bits_int ~size:b 0)
-      ) relocation.assertions;
-      let (last, first) = relocation.mask in
-      let masked = Exp.Typed.extract ~first ~last value in
-      
-      relocation.target
+      let State.Relocation.{value;asserts;target} = State.Relocation.of_elf relocation in
+      List.iter (State.push_relocation_assert state) asserts;
+
+      target
       |> Isla.Relocation.segments_of_reloc
       |> SMap.of_list
-      |> SMap.map (fun (first, last) -> Exp.Typed.extract ~first ~last masked)
+      |> SMap.map (fun (first, last) -> Exp.Typed.extract ~first ~last value)
       )
     |> Option.value ~default:SMap.empty
   in

From 9d5173e6d4a5e6f60ba8ef9ec624d744b26cf50f Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 20 Jan 2025 22:46:43 +0000
Subject: [PATCH 036/116] Fix loading relocations

---
 src/elf/linksemRelocatable.ml | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
index 2123d8f3..d822c2fa 100644
--- a/src/elf/linksemRelocatable.ml
+++ b/src/elf/linksemRelocatable.ml
@@ -51,7 +51,20 @@ let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_i
             else
               Byte_sequence.offset_and_cut addr_offset size section.elf64_section_body
             in
-            Error.bind (get_relocs section.elf64_section_name_as_string) @@ fun relocs ->
+            Error.bind (get_relocs section.elf64_section_name_as_string) @@ fun (AArch64 relocs) ->
+              let relocs = relocs
+              |> Pmap.bindings_list
+              |> List.fold_left (fun m (pos, r) ->
+                  let sz = size in
+                  let open Z in
+                  let open Compare in
+                  if pos >= addr_offset && pos < addr_offset + sz then
+                    Pmap.add (pos - addr_offset) r m
+                  else
+                    m
+                ) (Pmap.empty Z.compare)
+              |> fun x -> AArch64 x
+              in
             Error.bind data @@ fun data ->
               Error.bind (String_table.get_string_at name strtab) @@ fun str ->
                 let write = Elf_file.flag_is_set Elf_section_header_table.shf_write section.elf64_section_flags in

From 04e3bc6765ca5571778ac2e6b71aff6bca4fc025 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 21 Jan 2025 11:35:25 +0000
Subject: [PATCH 037/116] Handle jumps

---
 src/state/base.ml | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 80a1c2a8..b6918d03 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -606,7 +606,13 @@ let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t
 
 let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
   let ctxt0 = function Var.Section _ -> Value.bv @@ BitVec.of_int ~size:64 0 | _ -> raise ConcreteEval.Symbolic in
-  let offset = addr |> ConcreteEval.eval ~ctxt:ctxt0 |> Value.expect_bv |> BitVec.to_int in
+  let open Option in
+  let* offset_exp = try
+    Some (ConcreteEval.eval ~ctxt:ctxt0 addr)
+  with
+    ConcreteEval.Symbolic -> None
+  in
+  let offset = offset_exp |> Value.expect_bv |> BitVec.to_int in
   let sections = Hashtbl.create 10 in
   Ast.Manip.exp_iter_var (function Var.Section s -> Hashtbl.add sections s () | _ -> ()) addr;
 
@@ -679,9 +685,7 @@ let set_pc ~(pc : Reg.t) (s : t) (pcval : int) =
   let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
 
-(* TODO *)
 let set_pc_sym ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
-  (* set_pc ~pc s pcval.offset *)
   let exp = Typed.(var ~typ:(Ty_BitVec 64) (Var.Section pcval.section) + bits_int ~size:64 pcval.offset) in
   let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval.offset ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
@@ -693,11 +697,8 @@ let bump_pc ~(pc : Reg.t) (s : t) (bump : int) =
   let new_pc = Elf.Address.(old_pc + bump) in
   set_pc_sym ~pc s new_pc
 
-(* TODO section + offset *)
 let concretize_pc ~(pc : Reg.t) (s : t) =
-  let pc_exp = get_reg_exp s pc in
-  try ConcreteEval.eval pc_exp |> Value.expect_bv |> BitVec.to_int |> set_pc ~pc s
-  with ConcreteEval.Symbolic -> ()
+  pc |> get_reg_exp s |> eval_address s |> Option.iter (set_pc_sym ~pc s)
 
 let set_last_pc state pc =
   assert (not @@ is_locked state);

From 646f6a50f5021a4fb2efcf34353debcfb74dc808 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 26 Jan 2025 18:24:48 +0000
Subject: [PATCH 038/116] Convert dwarf from linksem

---
 src/ctype/ctype.ml | 34 +++++++++++++++++-----------------
 src/dw/addr.ml     |  6 ++++++
 src/dw/func.ml     |  2 +-
 src/dw/loc.ml      | 25 +++++++++++++------------
 src/dw/var.ml      | 15 +++++++++------
 src/utils/sym.ml   |  3 +++
 6 files changed, 49 insertions(+), 36 deletions(-)
 create mode 100644 src/dw/addr.ml
 create mode 100644 src/utils/sym.ml

diff --git a/src/ctype/ctype.ml b/src/ctype/ctype.ml
index fab17f6b..1c876f37 100644
--- a/src/ctype/ctype.ml
+++ b/src/ctype/ctype.ml
@@ -81,17 +81,17 @@ end)
 (*****************************************************************************)
 (** {1 DWARF constants } *)
 
-let vDW_ATE_address = "DW_ATE_address" |> Dwarf.base_type_attribute_encode |> Z.to_int
+let vDW_ATE_address = "DW_ATE_address" |> Dwarf.base_type_attribute_encode |> Sym.to_int
 
-let vDW_ATE_boolean = "DW_ATE_boolean" |> Dwarf.base_type_attribute_encode |> Z.to_int
+let vDW_ATE_boolean = "DW_ATE_boolean" |> Dwarf.base_type_attribute_encode |> Sym.to_int
 
-let vDW_ATE_signed = "DW_ATE_signed" |> Dwarf.base_type_attribute_encode |> Z.to_int
+let vDW_ATE_signed = "DW_ATE_signed" |> Dwarf.base_type_attribute_encode |> Sym.to_int
 
-let vDW_ATE_signed_char = "DW_ATE_signed_char" |> Dwarf.base_type_attribute_encode |> Z.to_int
+let vDW_ATE_signed_char = "DW_ATE_signed_char" |> Dwarf.base_type_attribute_encode |> Sym.to_int
 
-let vDW_ATE_unsigned = "DW_ATE_unsigned" |> Dwarf.base_type_attribute_encode |> Z.to_int
+let vDW_ATE_unsigned = "DW_ATE_unsigned" |> Dwarf.base_type_attribute_encode |> Sym.to_int
 
-let vDW_ATE_unsigned_char = "DW_ATE_unsigned_char" |> Dwarf.base_type_attribute_encode |> Z.to_int
+let vDW_ATE_unsigned_char = "DW_ATE_unsigned_char" |> Dwarf.base_type_attribute_encode |> Sym.to_int
 
 (*****************************************************************************)
 (*****************************************************************************)
@@ -372,7 +372,7 @@ type conversion_context = { env : env; potential_link_name : string option }
 
 (** Get the id of a linksem [cupdie] *)
 let ids_of_cupdie ((cu, _, die) : Dwarf.cupdie) : cupdie_id =
-  (Z.to_int cu.cu_header.cuh_offset, Z.to_int die.die_offset)
+  (Sym.to_int cu.cu_header.cuh_offset, Sym.to_int die.die_offset)
 
 (** Pretty print the dwarf decl type
 
@@ -380,7 +380,7 @@ let ids_of_cupdie ((cu, _, die) : Dwarf.cupdie) : cupdie_id =
 let pp_decl (d : Dwarf.decl) =
   Pp.dprintf "File %s, line %d"
     (Option.value d.decl_file ~default:"?")
-    (d.decl_line |> Option.map Z.to_int |> Option.value ~default:0)
+    (d.decl_line |> Option.map Sym.to_int |> Option.value ~default:0)
 
 (** This exception is raised when the type we are trying to reach
     must came from another translation unit or later in the current one.
@@ -402,14 +402,14 @@ let expect_some_link = Option.value_fun ~default:(fun _ -> raise LinkError)
     Only integers, chars and bools supported. No floating points
 *)
 let base_type_of_linksem ?size ~encoding name =
-  let encoding = Z.to_int encoding in
+  let encoding = Sym.to_int encoding in
   if encoding = vDW_ATE_boolean then Cbool
   else if encoding = vDW_ATE_signed || encoding = vDW_ATE_unsigned then
     let size =
       Option.value_fail size "In Ctype.base_type_of_linksem: integer type %s do not have a size"
         name
     in
-    Cint { name; signed = encoding = vDW_ATE_signed; size = Z.to_int size; ischar = false }
+    Cint { name; signed = encoding = vDW_ATE_signed; size = Sym.to_int size; ischar = false }
   else if encoding = vDW_ATE_signed_char || encoding = vDW_ATE_unsigned_char then
     Cint { name; signed = encoding = vDW_ATE_signed_char; size = 1; ischar = true }
   else Raise.fail "In Ctype.base_of_linksem: encoding %x unknown" encoding
@@ -428,7 +428,7 @@ let rec field_of_linksem ~cc ((_, fname, ltyp, offseto) : linksem_field) : field
   debug "Processed field %t" Pp.(top (opt string) fname);
   let offset =
     match offseto with
-    | Some offset -> Z.to_int offset
+    | Some offset -> Sym.to_int offset
     (* assume missing offsets are zero - perhaps should only occur for union members*)
     | None -> 0
   in
@@ -469,7 +469,7 @@ and[@warning "-16"] struct_type_of_linksem ?(force_complete = false) ~cc ~cupdie
         match Hashtbl.find cc.env.lenv (ids_of_cupdie cupdie) with
         | CT (CT_struct_union (_, Atk_structure, _, msize, _, Some members)) ->
             let lsize = expect_some_link msize in
-            let size = Z.to_int lsize in
+            let size = Sym.to_int lsize in
             let cc = { cc with potential_link_name = Some name } in
             let struc : struc = struc_of_linksem ~cc name size members in
             IdMap.seti cc.env.structs id struc;
@@ -485,7 +485,7 @@ and[@warning "-16"] struct_type_of_linksem ?(force_complete = false) ~cc ~cupdie
       | CT (CT_struct_union (_, Atk_structure, _, msize, _, Some members)) ->
           let size =
             match msize with
-            | Some x -> Z.to_int x
+            | Some x -> Sym.to_int x
             | None ->
                 warn "Struct %s doesn't have size" name;
                 0
@@ -503,7 +503,7 @@ and[@warning "-16"] struct_type_of_linksem ?(force_complete = false) ~cc ~cupdie
 
 and enum_of_linksem ~cc:_ name llabels : enum =
   let labels = Hashtbl.create 5 in
-  List.iter (fun (_, name, value) -> Hashtbl.add labels (Z.to_int value) name) llabels;
+  List.iter (fun (_, name, value) -> Hashtbl.add labels (Sym.to_int value) name) llabels;
   { name; labels }
 
 and enum_type_of_linksem ~cc ~cupdie ~mname ~decl : unqualified =
@@ -529,13 +529,13 @@ and unqualified_of_linksem ?(force_complete = false) ~cc : linksem_t -> unqualif
   | CT (CT_pointer (_, Some t)) -> ptr @@ of_linksem_cc ~cc t
   | CT (CT_pointer (_, None)) -> voidstar
   | CT (CT_array (_, elem, l)) ->
-      Array { elem = of_linksem_cc ~cc elem; dims = List.map Fun.(fst %> Option.map Z.to_int) l }
+      Array { elem = of_linksem_cc ~cc elem; dims = List.map Fun.(fst %> Option.map Sym.to_int) l }
   | CT (CT_struct_union (cupdie, Atk_structure, mname, _, decl, _)) ->
       struct_type_of_linksem ~force_complete ~cc ~cupdie ~mname ~decl
   | CT (CT_struct_union (_, Atk_union, _, size, decl, _)) ->
       let size =
         match size with
-        | Some s -> Z.to_int s
+        | Some s -> Sym.to_int s
         | None ->
             warn "%t: Sizeless union defaulting to 8 for now" Pp.(top pp_decl decl);
             8
@@ -619,7 +619,7 @@ let env_of_linksem (lenv : linksem_env) : env =
           Option.(
             let+! name = mname and+ size = msize in
             if not @@ IdMap.mem env.structs name then
-              IdMap.add env.structs name @@ incomplete_struct name (Z.to_int size) |> ignore)
+              IdMap.add env.structs name @@ incomplete_struct name (Sym.to_int size) |> ignore)
       | _ -> ())
     lenv;
   (* Third phase: Add all the type to the result environement *)
diff --git a/src/dw/addr.ml b/src/dw/addr.ml
new file mode 100644
index 00000000..0604a6f7
--- /dev/null
+++ b/src/dw/addr.ml
@@ -0,0 +1,6 @@
+include Elf.Address
+
+let of_sym : Sym.t -> t = function
+| Dwarf.Offset (section, offset) -> { section; offset = Z.to_int offset }
+| _ -> Raise.fail "expected section+offset"
+
diff --git a/src/dw/func.ml b/src/dw/func.ml
index 18fdd676..a4d5894f 100644
--- a/src/dw/func.ml
+++ b/src/dw/func.ml
@@ -140,7 +140,7 @@ let of_linksem (elf : Elf.File.t) (tenv : Ctype.env) (lfun : linksem_t) =
     | None -> (
         match lfun.ss_entry_address with
         | Some a -> (
-            let addr = Elf.Address.{section = ".text"; offset = Nat_big_num.to_int a} in (* TODO this is wrong, need symbolic DWARF *)
+            let addr = Addr.of_sym a in
             match Elf.SymTable.of_addr_opt elf.symbols addr with
             | Some sym -> Some sym
             | None -> None
diff --git a/src/dw/loc.ml b/src/dw/loc.ml
index e9aacff2..5d03061a 100644
--- a/src/dw/loc.ml
+++ b/src/dw/loc.ml
@@ -83,44 +83,45 @@ type linksem_t = dwop list
 let vDW_OP_addr : int = 0x03
 
 (** The integer value of the DW_OP_reg0 constant in DWARF standard *)
-let vDW_OP_reg0 : int = Z.to_int Dwarf.vDW_OP_reg0
+let vDW_OP_reg0 : int = Sym.to_int Dwarf.vDW_OP_reg0
 
 (** The integer value of the DW_OP_breg0 constant in DWARF standard *)
-let vDW_OP_breg0 : int = Z.to_int Dwarf.vDW_OP_breg0
+let vDW_OP_breg0 : int = Sym.to_int Dwarf.vDW_OP_breg0
 
 (** Convert a linksem location description into a {!Loc.t}
 
     Very naive for now : If the list has a single element that we can translate
    directly, we do. Otherwise, we dump it into the {!t.Dwarf} constructor *)
 let of_linksem ?(amap = Arch.dwarf_reg_map ()) (elf : Elf.File.t) : linksem_t -> t =
-  let int_of_oav : Dwarf.operation_argument_value -> int = function
-    | OAV_natural n -> Z.to_int n
-    | OAV_integer i -> Z.to_int i
-    | _ -> failwith "Expected integer argument"
+  let sym_of_oav : Dwarf.operation_argument_value -> Sym.t = function
+  | OAV_natural n -> n
+  | OAV_integer i -> i
+  | _ -> failwith "Expected integer argument"
   in
+  let int_of_oav oav = oav |> sym_of_oav |> Sym.to_int in
   function
   (* Register *)
   | [({ op_semantics = OpSem_reg; _ } as op)] ->
-      let reg_num = Z.to_int op.op_code - vDW_OP_reg0 in
+      let reg_num = Sym.to_int op.op_code - vDW_OP_reg0 in
       if reg_num >= Array.length amap then
         failwith
           (Printf.sprintf "Loc.of_linksem: register number %d unknown, code %x, name %s" reg_num
-             (Z.to_int op.op_code) op.op_string)
+             (Sym.to_int op.op_code) op.op_string)
       else Register amap.(reg_num)
   (* RegisterOffset *)
   | [({ op_semantics = OpSem_breg; op_argument_values = [arg]; _ } as op)] ->
-      let reg_num = Z.to_int op.op_code - vDW_OP_breg0 in
+      let reg_num = Sym.to_int op.op_code - vDW_OP_breg0 in
       if reg_num >= Array.length amap then
         failwith
           (Printf.sprintf "Loc.of_linksem: register number %d unknown, code %x, name %s" reg_num
-             (Z.to_int op.op_code) op.op_string)
+             (Sym.to_int op.op_code) op.op_string)
       else RegisterOffset (amap.(reg_num), int_of_oav arg)
   (* StackFrame *)
   | [{ op_semantics = OpSem_fbreg; op_argument_values = [arg]; _ }] -> StackFrame (int_of_oav arg)
   (* Global *)
   | [{ op_semantics = OpSem_lit; op_code = code; op_argument_values = [arg]; _ }] as ops
-    when Z.to_int code = vDW_OP_addr -> (
-      let addr = Elf.Address.{ section = ".data"; offset = int_of_oav arg } in (* TODO this is wrong, need symbolic DWARF*)
+    when Sym.to_int code = vDW_OP_addr -> (
+      let addr = Addr.of_sym @@ sym_of_oav arg in
       try Global (Elf.SymTable.of_addr_with_offset elf.symbols @@ addr)
       with Not_found ->
         warn "Symbol at 0x%x not found in Loc.of_linksem" (int_of_oav arg);
diff --git a/src/dw/var.ml b/src/dw/var.ml
index 0e6d86d5..e453d61b 100644
--- a/src/dw/var.ml
+++ b/src/dw/var.ml
@@ -45,21 +45,24 @@
 (** This module contain all the definition to handle local and global variables
     as defined in the DWARF information of the target file *)
 
+type range = Addr.t * Addr.t option
+
 (** Type of a DWARF variable *)
-type t = { name : string; param : bool; ctype : Ctype.t; locs : ((int * int) * Loc.t) list }
+type t = { name : string; param : bool; ctype : Ctype.t; locs : (range * Loc.t) list }
 
 (** Type of a DWARF variable in linksem *)
 type linksem_t = Dwarf.sdt_variable_or_formal_parameter
 
 (** Merge contiguous location lists *)
 let rec loc_merge = function
-  | ((a1, b1), d1) :: ((a2, b2), d2) :: l when b1 = a2 && Loc.compare d1 d2 = 0 ->
+  | ((a1, b1), d1) :: ((a2, b2), d2) :: l when b1 = Some a2 && Loc.compare d1 d2 = 0 ->
       loc_merge (((a1, b2), d1) :: l)
   | a :: l -> a :: loc_merge l
   | [] -> []
 
-(** Convert from Z.t to int, if there is an overflow, returns Int.max_int instead of throwing *)
-let clamp_z z = try Z.to_int z with Z.Overflow when Z.compare z Z.zero > 0 -> Int.max_int
+let end_addr_of_sym = function
+| Dwarf.Absolute z when Z.compare z (Z.of_int Int.max_int) > 0 -> None
+| x -> Some (Addr.of_sym x)
 
 (** Create a DWARF variable from its linksem counterpart *)
 let of_linksem (elf : Elf.File.t) (env : Ctype.env) (lvar : linksem_t) : t =
@@ -72,7 +75,7 @@ let of_linksem (elf : Elf.File.t) (env : Ctype.env) (lvar : linksem_t) : t =
   in
   let locs =
     lvar.svfp_locations |> Option.value ~default:[]
-    |> List.map (fun (a, b, l) -> ((Z.to_int a, clamp_z b), Loc.of_linksem elf l))
+    |> List.map (fun (a, b, l) -> ((Addr.of_sym a, end_addr_of_sym b), Loc.of_linksem elf l))
     |> loc_merge
   in
   { name; param; ctype; locs }
@@ -85,5 +88,5 @@ let pp_raw v =
       [
         ("name", string v.name);
         ("ctype", Ctype.pp v.ctype);
-        ("locs", list (pair (pair ptr ptr) Loc.pp) v.locs);
+        ("locs", list (pair (pair Addr.pp (opt Addr.pp)) Loc.pp) v.locs);
       ])
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
new file mode 100644
index 00000000..bb2ecd56
--- /dev/null
+++ b/src/utils/sym.ml
@@ -0,0 +1,3 @@
+type t = Z.t Dwarf.sym0
+
+let to_int x = Z.to_int @@ Dwarf.sym_unwrap x "to_int"
\ No newline at end of file

From 6f086f2896b91da265891ddd60d36eb3d85c5ef3 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 26 Jan 2025 22:39:13 +0000
Subject: [PATCH 039/116] [wip] symbolic analyse

---
 src/analyse/CallGraph.ml         |  8 ++--
 src/analyse/ControlFlow.ml       | 80 ++++++++++++++++----------------
 src/analyse/ControlFlowPpDot.ml  |  8 ++--
 src/analyse/DwarfFrameInfo.ml    |  6 +--
 src/analyse/DwarfInliningInfo.ml |  6 +--
 src/analyse/DwarfLineInfo.ml     | 64 ++++++++++++-------------
 src/analyse/DwarfVarInfo.ml      | 38 +++++++--------
 src/analyse/Elf.ml               |  4 +-
 src/analyse/ElfSymbols.ml        |  4 +-
 src/analyse/Pp.ml                | 10 ++--
 src/analyse/QemuLog.ml           |  4 +-
 src/analyse/Utils.ml             |  9 +++-
 src/utils/sym.ml                 | 17 ++++++-
 13 files changed, 139 insertions(+), 119 deletions(-)

diff --git a/src/analyse/CallGraph.ml b/src/analyse/CallGraph.ml
index e90602e1..026db808 100644
--- a/src/analyse/CallGraph.ml
+++ b/src/analyse/CallGraph.ml
@@ -60,7 +60,7 @@ type call_graph_node = addr * index * string list
 let mk_call_graph test (an : CollectedType.analysis) =
   let mask_addr x:natural =
     if !Globals.morello
-    then Nat_big_num.shift_left (Nat_big_num.shift_right x 1) 1
+    then Sym.shift_left (Sym.shift_right x 1) 1
     else x in
   (* take the nodes to be all the elf symbol addresses of stt_func
      symbol type (each with their list of elf symbol names) together
@@ -110,7 +110,7 @@ let mk_call_graph test (an : CollectedType.analysis) =
                        if
                          not
                            (List.exists
-                              (function (a'', _) -> Nat_big_num.equal a' a'')
+                              (function (a'', _) -> Sym.equal a' a'')
                               elf_symbols)
                        then Some (a', ["FROM BL:" ^ s'])
                        else None)
@@ -122,7 +122,7 @@ let mk_call_graph test (an : CollectedType.analysis) =
     match axs with
     | [] -> acc
     | (a, x) :: axs' ->
-        if not (List.exists (function (a', _) -> Nat_big_num.equal a a') acc) then
+        if not (List.exists (function (a', _) -> Sym.equal a a') acc) then
           dedup axs' ((a, x) :: acc)
         else dedup axs' acc
   in
@@ -133,7 +133,7 @@ let mk_call_graph test (an : CollectedType.analysis) =
     List.sort
       (function
         | (a, _) -> (
-            function (a', _) -> Nat_big_num.compare a a'
+            function (a', _) -> Sym.compare a a'
           ))
       (elf_symbols @ extra_bl_targets)
   in
diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 9d9628c0..89bc11f6 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -119,11 +119,11 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
               with
               | (a_br, a_table, n, shift, a_offset) ->
                   Some
-                    ( Nat_big_num.of_int a_br,
-                      ( Nat_big_num.of_int a_table,
-                        Nat_big_num.of_int n,
+                    ( Sym.of_int a_br,
+                      ( Sym.of_int a_table,
+                        Sym.of_int n,
                         shift,
-                        Nat_big_num.of_int a_offset ) )
+                        Sym.of_int a_offset ) )
               | exception _ -> fatal "couldn't parse branch table data file line: \"%s\"\n" s
             in
             List.filter_map parse_line (List.tl (Array.to_list lines))
@@ -131,7 +131,7 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
   in
 
   (* pull out .rodata section from ELF *)
-  let ((_, rodata_addr, bs) as _rodata : Dwarf.p_context * Nat_big_num.num * BytesSeq.t) =
+  let ((_, rodata_addr, bs) as _rodata : Dwarf.p_context * Sym.t * BytesSeq.t) =
     Dwarf.extract_section_body_without_relocations test.elf_file ".rodata" false
   in
   (* chop into bytes *)
@@ -143,37 +143,37 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
 
   let read_rodata_b addr =
     Elf_types_native_uint.natural_of_byte
-      rodata_bytes.(Nat_big_num.to_int (Nat_big_num.sub addr rodata_addr))
+      rodata_bytes.(Sym.to_int (Sym.sub addr rodata_addr))
   in
   let read_rodata_h addr =
-    Nat_big_num.add (read_rodata_b addr)
-      (Nat_big_num.mul (Nat_big_num.of_int 256)
-         (read_rodata_b (Nat_big_num.add addr (Nat_big_num.of_int 1))))
+    Sym.add (read_rodata_b addr)
+      (Sym.mul (Sym.of_int 256)
+         (read_rodata_b (Sym.add addr (Sym.of_int 1))))
   in
 
   let sign_extend_W n =
-    let half = Nat_big_num.mul (Nat_big_num.of_int 65536) (Nat_big_num.of_int 32768) in
-    let whole = Nat_big_num.mul half (Nat_big_num.of_int 2) in
-    if Nat_big_num.greater_equal n half then Nat_big_num.sub n whole else n
+    let half = Sym.mul (Sym.of_int 65536) (Sym.of_int 32768) in
+    let whole = Sym.mul half (Sym.of_int 2) in
+    if Sym.greater_equal n half then Sym.sub n whole else n
   in
 
   let read_rodata_W addr =
     sign_extend_W
-      (Nat_big_num.add (read_rodata_b addr)
-         (Nat_big_num.add
-            (Nat_big_num.mul (Nat_big_num.of_int 256)
-               (read_rodata_b (Nat_big_num.add addr (Nat_big_num.of_int 1))))
-            (Nat_big_num.add
-               (Nat_big_num.mul (Nat_big_num.of_int 65536)
-                  (read_rodata_b (Nat_big_num.add addr (Nat_big_num.of_int 2))))
-               (Nat_big_num.mul (Nat_big_num.of_int 16777216)
-                  (read_rodata_b (Nat_big_num.add addr (Nat_big_num.of_int 3)))))))
+      (Sym.add (read_rodata_b addr)
+         (Sym.add
+            (Sym.mul (Sym.of_int 256)
+               (read_rodata_b (Sym.add addr (Sym.of_int 1))))
+            (Sym.add
+               (Sym.mul (Sym.of_int 65536)
+                  (read_rodata_b (Sym.add addr (Sym.of_int 2))))
+               (Sym.mul (Sym.of_int 16777216)
+                  (read_rodata_b (Sym.add addr (Sym.of_int 3)))))))
   in
 
   let rec natural_assoc_opt n nys =
     match nys with
     | [] -> None
-    | (n', y) :: nys' -> if Nat_big_num.equal n n' then Some y else natural_assoc_opt n nys'
+    | (n', y) :: nys' -> if Sym.equal n n' then Some y else natural_assoc_opt n nys'
   in
 
   (* this is the evaluator for a little stack-machine language used in the hafnium.branch-table files to describe the access pattern for each branch table *)
@@ -187,8 +187,8 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
    h          read two bytes from the branch table
    W          read four byte from the branch table and sign-extend
                                                             *)
-  let rec eval_shift_expression (shift : string) (a_table : Nat_big_num.num)
-      (a_offset : Nat_big_num.num) (i : Nat_big_num.num) (stack : Nat_big_num.num list) (pc : int)
+  let rec eval_shift_expression (shift : string) (a_table : Sym.t)
+      (a_offset : Sym.t) (i : Sym.t) (stack : Sym.t list) (pc : int)
       =
     if pc = String.length shift then
       match stack with
@@ -205,8 +205,8 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
         match stack with
         | a :: stack' ->
             let a' =
-              Nat_big_num.mul a
-                (Nat_big_num.pow_int_positive 2 (Char.code command - Char.code '0'))
+              Sym.mul a
+                (Sym.pow_int_positive 2 (Char.code command - Char.code '0'))
             in
             eval_shift_expression shift a_table a_offset i (a' :: stack') (pc + 1)
         | _ -> fatal "eval_shift_expression shift empty stack"
@@ -222,7 +222,7 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
         (* plus *)
         match stack with
         | a1 :: a2 :: stack' ->
-            let a' = Nat_big_num.add a1 a2 in
+            let a' = Sym.add a1 a2 in
             eval_shift_expression shift a_table a_offset i (a' :: stack') (pc + 1)
         | _ -> fatal "eval_shift_expression plus emptyish stack"
       else if command = 'b' then
@@ -254,24 +254,24 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
       (function
         | (a_br, (a_table, size, shift, a_offset)) ->
             let rec f i =
-              if i > Nat_big_num.to_int size then []
+              if i > Sym.to_int size then []
               else
                 let a_target =
                   if shift = "2" then
-                    let table_entry_addr = Nat_big_num.add a_table (Nat_big_num.of_int (4 * i)) in
+                    let table_entry_addr = Sym.add a_table (Sym.of_int (4 * i)) in
                     match natural_assoc_opt table_entry_addr rodata_words with
                     | None ->
                         fatal "no branch table entry for address %s\n" (pp_addr table_entry_addr)
                     | Some table_entry ->
                         let a_target =
-                          Nat_big_num.modulus
-                            (Nat_big_num.add a_table table_entry)
-                            (Nat_big_num.pow_int_positive 2 32)
+                          Sym.modulus
+                            (Sym.add a_table table_entry)
+                            (Sym.pow_int_positive 2 32)
                         in
                         (* that 32 is good for the sign-extended negative 32-bit offsets we see
                            in the old hafnium-playground-src branch tables *)
                         a_target
-                  else eval_shift_expression shift a_table a_offset (Nat_big_num.of_int i) [] 0
+                  else eval_shift_expression shift a_table a_offset (Sym.of_int i) [] 0
                 in
                 a_target :: f (i + 1)
             in
@@ -289,10 +289,10 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
 
 let parse_addr (s : string) : natural =
 try 
-  Scanf.sscanf s "0x%Lx" (fun i64 -> Nat_big_num.of_int64 i64)
+  Scanf.sscanf s "0x%Lx" (fun i64 -> Sym.of_int64 i64)
 with
   Scanf.Scan_failure _  ->
-   Scanf.sscanf s "%Lx" (fun i64 -> Nat_big_num.of_int64 i64)
+   Scanf.sscanf s "%Lx" (fun i64 -> Sym.of_int64 i64)
 
 let parse_target s =
   match Scanf.sscanf s " %s %s" (fun s1 s2 -> (s1, s2)) with
@@ -360,7 +360,7 @@ let parse_control_flow_instruction s mnemonic s' : control_flow_insn =
 
 let targets_of_control_flow_insn_without_index branch_table_targets (addr : natural)
     (opcode_bytes : int list) (c : control_flow_insn) : (target_kind * addr * string) list =
-  let succ_addr = Nat_big_num.add addr (Nat_big_num.of_int (List.length opcode_bytes)) in
+  let succ_addr = Sym.add addr (Sym.of_int (List.length opcode_bytes)) in
   let targets =
     match c with
     | C_no_instruction -> []
@@ -465,7 +465,7 @@ let parse_objdump_line (s : string) : objdump_instruction option =
   if Str.string_match objdump_line_regexp s 0 then
     begin
       let addr_int64 = parse_hex_int64 (Str.matched_group 1 s) in
-      let addr = Nat_big_num.of_int64 addr_int64 in
+      let addr = Sym.of_int64 addr_int64 in
       let op = Str.matched_group 2 s in
       let op = strip_whitespace op in
       let opcode_byte_strings =
@@ -497,7 +497,7 @@ let rec parse_objdump_lines arch lines (next_index : int) (last_address : natura
         match last_address with
         | None -> i :: parse_objdump_lines arch lines (next_index + 1) (Some addr)
         | Some last_address' ->
-            let last_address'' = Nat_big_num.add last_address' (Nat_big_num.of_int 4) in
+            let last_address'' = Sym.add last_address' (Sym.of_int 4) in
             if addr > last_address'' then
               (* fake up "missing" instructions for any gaps in the address space*)
               (*warn "gap in objdump instruction address sequence at %s" (pp_addr last_address'');*)
@@ -602,11 +602,11 @@ let highlight c =
 
 (* highlight branch targets to earlier addresses*)
 let pp_target_addr_wrt (addr : natural) (c : control_flow_insn) (a : natural) =
-  (if highlight c && Nat_big_num.less a addr then "^" else "") ^ pp_addr a
+  (if highlight c && Sym.less a addr then "^" else "") ^ pp_addr a
 
 (* highlight branch come-froms from later addresses*)
 let pp_come_from_addr_wrt (addr : natural) (c : control_flow_insn) (a : natural) =
-  (if highlight c && Nat_big_num.greater a addr then "v" else "") ^ pp_addr a
+  (if highlight c && Sym.greater a addr then "v" else "") ^ pp_addr a
 
 (*
 let pp_branch_targets (xs : (addr * control_flow_insn * (target_kind * addr * int * string) list) list)
diff --git a/src/analyse/ControlFlowPpDot.ml b/src/analyse/ControlFlowPpDot.ml
index fc3f90ac..77375477 100644
--- a/src/analyse/ControlFlowPpDot.ml
+++ b/src/analyse/ControlFlowPpDot.ml
@@ -204,7 +204,7 @@ let inlining_stack_at_index (an : analysis) k =
               (function
                 | sss' ->
                     String.concat "\n---\n"
-                      (List.map (Dwarf.pp_sdt_subroutine (Nat_big_num.of_int 0)) sss'))
+                      (List.map (Dwarf.pp_sdt_subroutine (Sym.of_int 0)) sss'))
               maximal));
       []
 
@@ -793,7 +793,7 @@ let mk_cfg test an visitedo node_name_prefix (recurse_flat : bool) (_inline_all
                            let ((_comp_dir, _dir, _file) as ufe) =
                              Dwarf.unpack_file_entry lnh lnr.lnr_file
                            in
-                           (ufe, Nat_big_num.to_int lnr.lnr_line))
+                           (ufe, Sym.to_int lnr.lnr_line))
                      an.line_info.(k))
               in
 
@@ -859,12 +859,12 @@ let mk_cfg test an visitedo node_name_prefix (recurse_flat : bool) (_inline_all
                       match new_ss_O2_ambient_option with
                       | None ->
                           fatal "no call site for\n%s"
-                            (Dwarf.pp_sdt_subroutine (Nat_big_num.of_int 0) ss_current)
+                            (Dwarf.pp_sdt_subroutine (Sym.of_int 0) ss_current)
                       | Some new_ss_O2_ambient -> (
                           match new_ss_O2_ambient.ss_call_site with
                           | None ->
                               fatal "no call site2 for\n%s"
-                                (Dwarf.pp_sdt_subroutine (Nat_big_num.of_int 0) ss_current)
+                                (Dwarf.pp_sdt_subroutine (Sym.of_int 0) ss_current)
                           | Some (_ufe, line, _subprogram_name) -> line
                         )
                       (*,
diff --git a/src/analyse/DwarfFrameInfo.ml b/src/analyse/DwarfFrameInfo.ml
index 2b41c478..991b295d 100644
--- a/src/analyse/DwarfFrameInfo.ml
+++ b/src/analyse/DwarfFrameInfo.ml
@@ -56,11 +56,11 @@ let aof ((a : natural), (_cfa : string), (_regs : (string * string) list)) = a
 let rec f (aof : 'b -> natural) (a : natural) (last : 'b option) (bs : 'b list) : 'b option =
   match (last, bs) with
   | (None, []) -> None
-  | (Some b', []) -> if Nat_big_num.greater_equal a (aof b') then Some b' else None
+  | (Some b', []) -> if Sym.greater_equal a (aof b') then Some b' else None
   | (None, b'' :: bs') -> f aof a (Some b'') bs'
   | (Some b', b'' :: bs') ->
-      if Nat_big_num.less a (aof b') then None
-      else if Nat_big_num.greater_equal a (aof b') && Nat_big_num.less a (aof b'') then Some b'
+      if Sym.less a (aof b') then None
+      else if Sym.greater_equal a (aof b') && Sym.less a (aof b'') then Some b'
       else f aof a (Some b'') bs'
 
 let mk_frame_info test instructions :
diff --git a/src/analyse/DwarfInliningInfo.ml b/src/analyse/DwarfInliningInfo.ml
index bc6a1903..832b4cac 100644
--- a/src/analyse/DwarfInliningInfo.ml
+++ b/src/analyse/DwarfInliningInfo.ml
@@ -68,7 +68,7 @@ let mk_inlining test sdt instructions =
       let addr = i.i_addr in
       let issr_still_current =
         List.filter
-          (function (_label, ((_n1, n2), (_m, _n), _is)) -> Nat_big_num.less addr n2)
+          (function (_label, ((_n1, n2), (_m, _n), _is)) -> Sym.less addr n2)
           issr_current
       in
 
@@ -83,8 +83,8 @@ let mk_inlining test sdt instructions =
 
       let (issr_starting_here0, issr_rest') =
         find_first
-          (function ((_n1, n2), (_m, _n), _is) -> Nat_big_num.less_equal n2 addr)
-          (function ((n1, _n2), (_m, _n), _is) -> Nat_big_num.equal n1 addr)
+          (function ((_n1, n2), (_m, _n), _is) -> Sym.less_equal n2 addr)
+          (function ((n1, _n2), (_m, _n), _is) -> Sym.equal n1 addr)
           [] issr_rest
       in
 
diff --git a/src/analyse/DwarfLineInfo.ml b/src/analyse/DwarfLineInfo.ml
index cf126a41..b3561313 100644
--- a/src/analyse/DwarfLineInfo.ml
+++ b/src/analyse/DwarfLineInfo.ml
@@ -86,18 +86,18 @@ type evaluated_line_info_for_instruction = {
 (* line number sequences can overlap, and we have to walk through instructions (not addresses), so we simplify by splitting all of them into individual entries, sort them by first address, and then walk through them painting a per-instruction array.  This is algorithmically a bit terrible, but seems to add only a couple of seconds to read-dwarf rd *)
 
 let pp_line_number_header_concise (lnh : Dwarf.line_number_header) : string =
-  "lnh offset =    " ^ Dwarf.pphex lnh.lnh_offset ^ "\n"
+  "lnh offset =    " ^ Dwarf.pphex_sym lnh.lnh_offset ^ "\n"
 
 (*^ ("dwarf_format =                       " ^ (pp_dwarf_format lnh.lnh_dwarf_format ^ ("\n"
-^ ("unit_length =                        " ^ (Nat_big_num.to_string lnh.lnh_unit_length ^ ("\n"
-^ ("version =                            " ^ (Nat_big_num.to_string lnh.lnh_version ^ ("\n"
-^ ("header_length =                      " ^ (Nat_big_num.to_string lnh.lnh_header_length ^ ("\n"
-^ ("minimum_instruction_length =         " ^ (Nat_big_num.to_string lnh.lnh_minimum_instruction_length ^ ("\n"
-^ ("maximum_operations_per_instruction = " ^ (Nat_big_num.to_string lnh.lnh_maximum_operations_per_instruction ^ ("\n"
+^ ("unit_length =                        " ^ (Sym.to_string lnh.lnh_unit_length ^ ("\n"
+^ ("version =                            " ^ (Sym.to_string lnh.lnh_version ^ ("\n"
+^ ("header_length =                      " ^ (Sym.to_string lnh.lnh_header_length ^ ("\n"
+^ ("minimum_instruction_length =         " ^ (Sym.to_string lnh.lnh_minimum_instruction_length ^ ("\n"
+^ ("maximum_operations_per_instruction = " ^ (Sym.to_string lnh.lnh_maximum_operations_per_instruction ^ ("\n"
 ^ ("default_is_stmt =                    " ^ (string_of_bool lnh.lnh_default_is_stmt ^ ("\n"
-^ ("line_base =                          " ^ (Nat_big_num.to_string lnh.lnh_line_base ^ ("\n"
-^ ("line_range =                         " ^ (Nat_big_num.to_string lnh.lnh_line_range ^ ("\n"
-^ ("opcode_base =                        " ^ (Nat_big_num.to_string lnh.lnh_opcode_base ^ ("\n"
+^ ("line_base =                          " ^ (Sym.to_string lnh.lnh_line_base ^ ("\n"
+^ ("line_range =                         " ^ (Sym.to_string lnh.lnh_line_range ^ ("\n"
+^ ("opcode_base =                        " ^ (Sym.to_string lnh.lnh_opcode_base ^ ("\n"
 ^ ("standard_opcode_lengths =            " ^ (string_of_list
   instance_Show_Show_Num_natural_dict lnh.lnh_standard_opcode_lengths ^ ("\n"
 ^ ("comp_dir =                           " ^ (string_of_maybe
@@ -136,7 +136,7 @@ let split_into_sequences
             | None -> fatal "split_into_sequences found sequence of length 0"
           in
           let last = lnr.lnr_address in
-          if Nat_big_num.equal first last then fatal "split_into_sequences found first=last"
+          if Sym.equal first last then fatal "split_into_sequences found first=last"
           else ();
           let elis =
             {
@@ -160,8 +160,8 @@ let split_into_entries (s : evaluated_line_info_sequence) : evaluated_line_info_
           {
             elie_first = l1.lnr_address;
             elie_last =
-              ( if Nat_big_num.equal l2.lnr_address l1.lnr_address then l1.lnr_address
-              else Nat_big_num.sub l2.lnr_address (Nat_big_num.of_int 1)
+              ( if Sym.equal l2.lnr_address l1.lnr_address then l1.lnr_address
+              else Sym.sub l2.lnr_address (Sym.of_int 1)
               );
             elie_lnh = s.elis_lnh;
             elie_lnr = l1;
@@ -176,9 +176,9 @@ let split_into_entries (s : evaluated_line_info_sequence) : evaluated_line_info_
 
 let mk_line_info (eli: Dwarf.evaluated_line_info) instructions : evaluated_line_info_for_instruction option array =
   let sequences = List.flatten (List.map split_into_sequences eli) in
-  let compare_sequence s1 s2 = Nat_big_num.compare s1.elis_first s2.elis_first in
+  let compare_sequence s1 s2 = Sym.compare s1.elis_first s2.elis_first in
   let sequences_sorted = List.sort compare_sequence sequences in
-  (*let overlap_sequence s1 s2 = not( Nat_big_num.greater_equal s2.first s1.last || Nat_big_num.greater_equal s1.first s2.last) in*)
+  (*let overlap_sequence s1 s2 = not( Sym.greater_equal s2.first s1.last || Sym.greater_equal s1.first s2.last) in*)
 
   Printf.printf "mk_line_info\n%s" (String.concat "\n" (List.map pp_sequence_concise sequences_sorted));
 
@@ -189,12 +189,12 @@ let mk_line_info (eli: Dwarf.evaluated_line_info) instructions : evaluated_line_
     let (discardable,remaining') =
       List.partition
         (function sequence ->
-           Nat_big_num.less_equal sequence.elis_last addr)
+           Sym.less_equal sequence.elis_last addr)
         remaining_sequences in
     let (sequences,remaining'') =
       List.partition
         (function sequence ->
-           Nat_big_num.less_equal sequence.elis_first addr)
+           Sym.less_equal sequence.elis_first addr)
         remaining' in
     (sequences,remaining'') in
 
@@ -224,7 +224,7 @@ let mk_line_info (eli: Dwarf.evaluated_line_info) instructions : evaluated_line_
       let addr = instructions.(k).i_addr in
       match remaining_lines with
       | l1::((l2::remaining_lines') as remaining_lines'') ->
-         if Nat_big_num.equal addr l1.lnr_address then
+         if Sym.equal addr l1.lnr_address then
            (* this instruction address exactly matches the first line of this sequence *)
            let elifi = {
                elifi_start = true;
@@ -232,7 +232,7 @@ let mk_line_info (eli: Dwarf.evaluated_line_info) instructions : evaluated_line_
                elifi_line = l1 } in
            elifis.(k) <- Some elifi;
            f active_sequence remaining_lines remaining_sequences (k+1)
-         else if Nat_big_num.less l1.lnr_address addr && Nat_big_num.less addr l2.lnr_address then
+         else if Sym.less l1.lnr_address addr && Sym.less addr l2.lnr_address then
            (* this instruction address is within the range of the first line, but not equal to it*)
            let elifi = {
                elifi_start = false;
@@ -240,7 +240,7 @@ let mk_line_info (eli: Dwarf.evaluated_line_info) instructions : evaluated_line_
                elifi_line = l1 } in
            elifis.(k) <- Some elifi;
            f active_sequence remaining_lines remaining_sequences (k+1)
-         else if Nat_big_num.greater_equal addr l2.lnr_address then
+         else if Sym.greater_equal addr l2.lnr_address then
            (* this instruction address is after the range of the first line *)
            if not(l2.lnr_end_sequence (* invariant: iff remaining'=[]*)) then
              (* there are more non-end lines left in this sequence: try again with the next *)
@@ -268,11 +268,11 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
   let elifis = Array.make size [] in
 
   let sequences = List.flatten (List.map split_into_sequences eli) in
-  let compare_sequence s1 s2 = Nat_big_num.compare s1.elis_first s2.elis_first in
+  let compare_sequence s1 s2 = Sym.compare s1.elis_first s2.elis_first in
   let sequences_sorted = List.sort compare_sequence sequences in
 
   let entries = List.flatten (List.map split_into_entries sequences_sorted) in
-  let compare_entry e1 e2 = Nat_big_num.compare e1.elie_first e2.elie_first in
+  let compare_entry e1 e2 = Sym.compare e1.elie_first e2.elie_first in
   let entries_sorted = List.sort compare_entry entries in
 
   (*List.iter (function elie -> Printf.printf "%s" (pp_elie_concise elie)) entries_sorted;*)
@@ -285,7 +285,7 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
         match remaining with
         | [] -> (acc, remaining)
         | elie :: remaining' ->
-            if Nat_big_num.less_equal elie.elie_first addr then
+            if Sym.less_equal elie.elie_first addr then
               mk_new_perhaps_relevant (elie :: acc) remaining'
             else (acc, remaining)
       in
@@ -293,7 +293,7 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
       let (new_perhaps_relevant, remaining') = mk_new_perhaps_relevant [] remaining_entries in
 
       let addr_in elie =
-        Nat_big_num.less_equal elie.elie_first addr && Nat_big_num.less_equal addr elie.elie_last
+        Sym.less_equal elie.elie_first addr && Sym.less_equal addr elie.elie_last
       in
 
       let still_active_entries =
@@ -305,7 +305,7 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
           (function
             | elie ->
                 let elifi =
-                  { elifi_start = Nat_big_num.equal addr elie.elie_first; elifi_entry = elie }
+                  { elifi_start = Sym.equal addr elie.elie_first; elifi_entry = elie }
                 in
                 elifi)
           still_active_entries;
@@ -443,14 +443,14 @@ let pp_dwarf_source_file_lines' m (ds : Dwarf.dwarf_static) (pp_actual_line : bo
     | Ascii -> s
     | Html ->
         "@<a class=\"link-inst\" href=\"" ^ "" ^ file ^ ".html#"
-        ^ Nat_big_num.to_string lnr.lnr_line
+        ^ Sym.to_string lnr.lnr_line
         ^ "\">" ^ s ^ "</a>@ "
   in
   wrap_link m
     (subprogram_name ^ ":"
-    ^ Nat_big_num.to_string lnr.lnr_line
+    ^ Sym.to_string lnr.lnr_line
     ^ "."
-    ^ Nat_big_num.to_string lnr.lnr_column
+    ^ Sym.to_string lnr.lnr_column
     ^ " (" ^ file ^ ")"
     )
   (*  ^ (if elifi.elifi_start then "S" else "s")*)
@@ -463,10 +463,10 @@ let pp_dwarf_source_file_lines' m (ds : Dwarf.dwarf_static) (pp_actual_line : bo
   ^ " "
   ^
   if pp_actual_line then
-    let line = Nat_big_num.to_int lnr.lnr_line in
+    let line = Sym.to_int lnr.lnr_line in
     if line = 0 then "line 0"
     else
-      pp_source_line (source_line (comp_dir, dir, file) line) (Nat_big_num.to_int lnr.lnr_column)
+      pp_source_line (source_line (comp_dir, dir, file) line) (Sym.to_int lnr.lnr_column)
   else ""
 
 (* OLD source line number for O0/2 correlation
@@ -479,11 +479,11 @@ let rec dwarf_source_file_line_numbers' test recursion_limit (a : natural) :
     match sls with
     | [] ->
         dwarf_source_file_line_numbers' test (recursion_limit - 1)
-          (Nat_big_num.sub a (Nat_big_num.of_int 4))
+          (Sym.sub a (Sym.of_int 4))
     | _ ->
         List.map
           (fun ((comp_dir, dir, file), n, lnr, subprogram_name) ->
-            (subprogram_name, Nat_big_num.to_int n))
+            (subprogram_name, Sym.to_int n))
           sls
 
 let dwarf_source_file_line_numbers test (a : natural) =
@@ -507,7 +507,7 @@ let dwarf_source_file_line_numbers_by_index test line_info k :
                    Dwarf.subprogram_at_line test.dwarf_static.ds_subprogram_line_extents ufe
                      lnr.lnr_line )
                in
-               (subprogram_name, Nat_big_num.to_int lnr.lnr_line))
+               (subprogram_name, Sym.to_int lnr.lnr_line))
          elifis)
   in
   match lines with [_] -> lines | [] -> lines | _ -> []
diff --git a/src/analyse/DwarfVarInfo.ml b/src/analyse/DwarfVarInfo.ml
index bd0709f0..54e2964f 100644
--- a/src/analyse/DwarfVarInfo.ml
+++ b/src/analyse/DwarfVarInfo.ml
@@ -76,7 +76,7 @@ let pp_sdt_concise_variable_or_formal_parameter_main (level : int)
   ^ (match svfp.svfp_type with None -> "none" | Some t -> Dwarf.pp_type_info_deep t)
   ^ "  "
   (*^ indent ^ "const_value:"*)
-  ^ (match svfp.svfp_const_value with None -> "" | Some v -> "const:" ^ Nat_big_num.to_string v)
+  ^ (match svfp.svfp_const_value with None -> "" | Some v -> "const:" ^ Sym.to_string v)
   ^ "  "
 
 (*^ indent ^ "external:" ^  show svfp.svfp_external ^ "\n"*)
@@ -90,7 +90,7 @@ let pp_sdt_concise_variable_or_formal_parameter (level : int) (is_params : bool)
   ^
   match svfp.svfp_locations with
   | None -> "no locations\n"
-  | Some [loc] -> " " ^ Dwarf.pp_parsed_single_location_description (Nat_big_num.of_int 0) loc
+  | Some [loc] -> " " ^ Dwarf.pp_parsed_single_location_description (Z.of_int 0) loc
   | Some locs ->
       "\n"
       ^ String.concat ""
@@ -99,7 +99,7 @@ let pp_sdt_concise_variable_or_formal_parameter (level : int) (is_params : bool)
                | loc ->
                    "+"
                    ^ Dwarf.pp_parsed_single_location_description
-                       (Nat_big_num.of_int (level + 1))
+                       (Z.of_int (level + 1))
                        loc)
              locs)
 
@@ -150,14 +150,14 @@ let rec locals_subroutine context (ss : Dwarf.sdt_subroutine) =
     ^ (indent (*^ "name:"                   ^*) ^ (pp_sdt_maybe ss.ss_name (fun name1 -> name1 ^ "\n")
   (*  ^ indent ^ "cupdie:"                 ^ pp_cupdie3 ss.ss_cupdie ^ "\n"*)
   ^ (indent ^ ("kind:"                   ^ (((match ss.ss_kind with SSK_subprogram -> "subprogram" | SSK_inlined_subroutine -> "inlined subroutine" )) ^ ("\n"
-  ^ (indent ^ ("call site:"              ^ (pp_sdt_maybe ss.ss_call_site (fun ud -> "\n" ^ (indent_level true (Nat_big_num.add level(Nat_big_num.of_int 1)) ^ (pp_ud ud ^ "\n")))
-  ^ (indent ^ ("abstract origin:"        ^ (pp_sdt_maybe ss.ss_abstract_origin (fun s -> "\n" ^ locals__subroutine (Nat_big_num.add level(Nat_big_num.of_int 1)) s)
+  ^ (indent ^ ("call site:"              ^ (pp_sdt_maybe ss.ss_call_site (fun ud -> "\n" ^ (indent_level true (Sym.add level(Sym.of_int 1)) ^ (pp_ud ud ^ "\n")))
+  ^ (indent ^ ("abstract origin:"        ^ (pp_sdt_maybe ss.ss_abstract_origin (fun s -> "\n" ^ locals__subroutine (Sym.add level(Sym.of_int 1)) s)
   (*  ^ indent ^ "type:"                   ^ pp_sdt_maybe ss.ss_type (fun typ -> pp_type_info_deep typ ^"\n" end)*)
-  ^ (indent ^ ("vars:"                   ^ (pp_sdt_list ss.ss_vars (pp_sdt_concise_variable_or_formal_parameter (Nat_big_num.add level(Nat_big_num.of_int 1)))
-  ^ (indent ^ ("unspecified_parameters:" ^ (pp_sdt_list ss.ss_unspecified_parameters (pp_sdt_unspecified_parameter (Nat_big_num.add level(Nat_big_num.of_int 1)))
+  ^ (indent ^ ("vars:"                   ^ (pp_sdt_list ss.ss_vars (pp_sdt_concise_variable_or_formal_parameter (Sym.add level(Sym.of_int 1)))
+  ^ (indent ^ ("unspecified_parameters:" ^ (pp_sdt_list ss.ss_unspecified_parameters (pp_sdt_unspecified_parameter (Sym.add level(Sym.of_int 1)))
   (*  ^ indent ^ "pc ranges:"              ^ pp_pc_ranges (level+1) ss.ss_pc_ranges*)
-  ^ (indent ^ ("subroutines:"            ^ (pp_sdt_list ss.ss_subroutines (locals__subroutine (Nat_big_num.add level(Nat_big_num.of_int 1)))
-  ^ (indent ^ ("lexical_blocks:"         ^ (pp_sdt_list ss.ss_lexical_blocks (locals__lexical_block (Nat_big_num.add level(Nat_big_num.of_int 1)))
+  ^ (indent ^ ("subroutines:"            ^ (pp_sdt_list ss.ss_subroutines (locals__subroutine (Sym.add level(Sym.of_int 1)))
+  ^ (indent ^ ("lexical_blocks:"         ^ (pp_sdt_list ss.ss_lexical_blocks (locals__lexical_block (Sym.add level(Sym.of_int 1)))
   (*  ^ indent ^ "decl:"                   ^ pp_sdt_maybe ss.ss_decl (fun ((ufe,line) as ud) -> "\n" ^ indent_level true (level+1) ^ pp_ufe ufe ^ " " ^ show line ^ "\n" end)*)
   (*  ^ indent ^ "noreturn:"               ^ show ss.ss_noreturn ^ "\n"*)
   (*  ^ indent ^ "external:"               ^ show ss.ss_external ^"\n"*)
@@ -172,10 +172,10 @@ and locals_lexical_block context (lb : Dwarf.sdt_lexical_block) =
 (*
   ""
   (*  ^ indent ^ "cupdie:"         ^ pp_cupdie3 lb.slb_cupdie ^ "\n"*)
-  ^ (indent ^ ("vars:"           ^ (pp_sdt_list lb.slb_vars (pp_sdt_concise_variable_or_formal_parameter (Nat_big_num.add level(Nat_big_num.of_int 1)))
+  ^ (indent ^ ("vars:"           ^ (pp_sdt_list lb.slb_vars (pp_sdt_concise_variable_or_formal_parameter (Sym.add level(Sym.of_int 1)))
   (*  ^ indent ^ "pc ranges:"      ^ pp_pc_ranges (level+1) lb.slb_pc_ranges*)
-  ^ (indent ^ ("subroutines :"   ^ (pp_sdt_list lb.slb_subroutines (locals__subroutine (Nat_big_num.add level(Nat_big_num.of_int 1)))
-  ^ (indent ^ ("lexical_blocks:" ^ (pp_sdt_list lb.slb_lexical_blocks (locals__lexical_block (Nat_big_num.add level(Nat_big_num.of_int 1)))
+  ^ (indent ^ ("subroutines :"   ^ (pp_sdt_list lb.slb_subroutines (locals__subroutine (Sym.add level(Sym.of_int 1)))
+  ^ (indent ^ ("lexical_blocks:" ^ (pp_sdt_list lb.slb_lexical_blocks (locals__lexical_block (Sym.add level(Sym.of_int 1)))
   ^ "\n"))))))))))
  *)
 
@@ -190,8 +190,8 @@ let locals_compilation_unit context (cu : Dwarf.sdt_compilation_unit) =
   ""
   ^ (indent (*^ "name:"         *) ^ (cu.scu_name ^ ("\n"
   (*  ^ indent ^ "cupdie:"       ^ pp_cupdie3 cu.scu_cupdie ^ "\n"*)
-  ^ (indent ^ ("vars:"         ^ (pp_sdt_list cu.scu_vars (pp_sdt_concise_variable_or_formal_parameter (Nat_big_num.add level(Nat_big_num.of_int 1)))
-  ^ (indent ^ ("subroutines :" ^ pp_sdt_list cu.scu_subroutines (locals__subroutine (Nat_big_num.add level(Nat_big_num.of_int 1))))))))))))
+  ^ (indent ^ ("vars:"         ^ (pp_sdt_list cu.scu_vars (pp_sdt_concise_variable_or_formal_parameter (Sym.add level(Sym.of_int 1)))
+  ^ (indent ^ ("subroutines :" ^ pp_sdt_list cu.scu_subroutines (locals__subroutine (Sym.add level(Sym.of_int 1))))))))))))
  *)
 let locals_dwarf (sdt_d : Dwarf.sdt_dwarf) :
     (Dwarf.sdt_variable_or_formal_parameter * string list) (*context*) list =
@@ -246,7 +246,7 @@ let pp_ranged_var (prefix : string) (var : ranged_var) : string =
   let ((n1, n2, ops), (svfp, context)) = var in
   prefix
   ^ pp_sdt_concise_variable_or_formal_parameter_main 0 svfp
-  ^ (let s = Dwarf.pp_parsed_single_location_description (Nat_big_num.of_int 0) (n1, n2, ops) in
+  ^ (let s = Dwarf.pp_parsed_single_location_description (Sym.of_int 0) (n1, n2, ops) in
      String.sub s 0 (String.length s - 1))
   (*hackish stripping of trailing \n from linksem - TODO: fix linksem interface*)
   ^ " "
@@ -299,14 +299,14 @@ let mk_ranged_vars_at_instructions (sdt_d : Dwarf.sdt_dwarf) instructions :
     if k >= size then ()
     else
       let addr = instructions.(k).i_addr in
-      if not (Nat_big_num.less addr_prev addr) then
+      if not (Sym.less addr_prev addr) then
         fatal "mk_ranged_vars_at_instructions found non-increasing address %s" (pp_addr addr);
       let (still_current, old) =
-        List.partition (function ((_, n2, _), _) -> Nat_big_num.less addr n2) prev
+        List.partition (function ((_, n2, _), _) -> Sym.less addr n2) prev
       in
       let (new', remaining') =
         partition_first
-          (function ((n1, _n2, _ops), _var) as _rv -> Nat_big_num.greater_equal addr n1)
+          (function ((n1, _n2, _ops), _var) as _rv -> Sym.greater_equal addr n1)
           remaining
       in
       (* TODO: do we need to drop any that have been totally skipped over? *)
@@ -317,7 +317,7 @@ let mk_ranged_vars_at_instructions (sdt_d : Dwarf.sdt_dwarf) instructions :
       rvai_remaining.(k) <- remaining';
       f addr current remaining' (k + 1)
   in
-  f (Nat_big_num.of_int (0 - 1)) [] locals_by_pc_ranges 0;
+  f (Sym.of_int (0 - 1)) [] locals_by_pc_ranges 0;
 
   {
     rvai_globals = globals_dwarf sdt_d;
diff --git a/src/analyse/Elf.ml b/src/analyse/Elf.ml
index 4b4bfc9b..0734c459 100644
--- a/src/analyse/Elf.ml
+++ b/src/analyse/Elf.ml
@@ -58,8 +58,8 @@ let pp_symbol_map (symbol_map : Elf_file.global_symbol_init_info) =
   String.concat ""
     (List.map
        (fun (name, (typ, _size, address, _mb, _binding)) ->
-         Printf.sprintf "**** name = %s  address = %s  typ = %d\n" name (pp_addr address)
-           (Nat_big_num.to_int typ))
+         Printf.sprintf "**** name = %s  address = %s  typ = %d\n" name (pp_addr (Dwarf.Absolute address))
+           (Sym.to_int (Dwarf.Absolute typ)))
        symbol_map)
 
 (*****************************************************************************)
diff --git a/src/analyse/ElfSymbols.ml b/src/analyse/ElfSymbols.ml
index e74f7aeb..83a526ea 100644
--- a/src/analyse/ElfSymbols.ml
+++ b/src/analyse/ElfSymbols.ml
@@ -54,7 +54,7 @@ open ControlFlowTypes
 let elf_symbols_of_address (test : test) (addr : natural) : string list =
   List.filter_map
     (fun (name, (_typ, _size, address, _mb, _binding)) ->
-      if address = addr then Some name else None)
+      if Dwarf.Absolute address = addr then Some name else None)
     test.symbol_map
 
 let mk_elf_symbols test instructions : string list array =
@@ -62,5 +62,5 @@ let mk_elf_symbols test instructions : string list array =
 
 let address_of_elf_symbol test (s : string) : addr option =
   List.find_map
-    (fun (name, (_typ, _size, address, _mb, _binding)) -> if s = name then Some address else None)
+    (fun (name, (_typ, _size, address, _mb, _binding)) -> if s = name then Some (Dwarf.Absolute address) else None)
     test.symbol_map
diff --git a/src/analyse/Pp.ml b/src/analyse/Pp.ml
index d9c749c3..87ce1bec 100644
--- a/src/analyse/Pp.ml
+++ b/src/analyse/Pp.ml
@@ -574,7 +574,7 @@ let pp_instructions_ranged m test an (low, high) =
   Printf.printf "pp_instructions_ranged indices: low=%i  high=%i \n"   (an.index_of_address low)  (an.index_of_address high);
  *)
   let index_low = an.index_of_address low in
-  let index_high = (an.index_of_address (Nat_big_num.sub high (Nat_big_num.of_int 4)))+1 in
+  let index_high = (an.index_of_address (Sym.sub high (Sym.of_int 4)))+1 in
   let rec subarray_map_to_list f a k k' =
     if k >= k' then [] else f k a.(k) :: subarray_map_to_list f a (k + 1) k'
   in
@@ -619,7 +619,7 @@ let chunks_of_ranged_cu m test an filename_stem ((low, high), cu) =
           pp_abbreviations_table cu'.cu_abbreviations_table );
         ( "die",
           ".debug_info die tree",
-          pp_die c cu'.cu_header d.d_str true (*indent*) (Nat_big_num.of_int 0) true cu'.cu_die );
+          pp_die c cu'.cu_header d.d_str true (*indent*) (Sym.of_int 0) true cu'.cu_die );
         ( "line",
           ".debug_line line number info",
           let lnp = line_number_program_of_compilation_unit d cu' in
@@ -628,13 +628,13 @@ let chunks_of_ranged_cu m test an filename_stem ((low, high), cu) =
           ".debug_line evaluated line info",
           let lnrs = evaluated_line_info_of_compilation_unit d cu' ds.ds_evaluated_line_info in
           pp_line_number_registerss lnrs );
-        ("sdt", "simple die tree", pp_sdt_compilation_unit (Nat_big_num.of_int 0) cu);
+        ("sdt", "simple die tree", pp_sdt_compilation_unit (Sym.of_int 0) cu);
         ( "sdt_globals",
           "simple die tree globals",
-          pp_sdt_globals_compilation_unit (Nat_big_num.of_int 0) cu );
+          pp_sdt_globals_compilation_unit (Sym.of_int 0) cu );
         ( "sdt_locals",
           "simple die tree locals",
-          pp_sdt_locals_compilation_unit (Nat_big_num.of_int 0) cu );
+          pp_sdt_locals_compilation_unit (Sym.of_int 0) cu );
         ("inlined", "inlined subroutine info", pp_inlined_subroutines ds iss);
         ( "inlined_by_range",
           "inlined subroutine info by range",
diff --git a/src/analyse/QemuLog.ml b/src/analyse/QemuLog.ml
index 9591bef5..e25a65c0 100644
--- a/src/analyse/QemuLog.ml
+++ b/src/analyse/QemuLog.ml
@@ -64,8 +64,8 @@ let read_qemu_log an filename_qemu_log : bool array =
           (*         Printf.printf "%s  " s;*)
           match Scanf.sscanf s "0x%x:%s" (fun addr _ -> addr) with
           | addr ->
-              (*Printf.printf "PARSED %s\n" (pp_addr (Nat_big_num.of_int addr));*)
-              Some (Nat_big_num.of_int addr)
+              (*Printf.printf "PARSED %s\n" (pp_addr (Sym.of_int addr));*)
+              Some (Sym.of_int addr)
           | exception _ -> (*Printf.printf "NOT\n";*) None
         in
         List.filter_map parse_line (Array.to_list lines)
diff --git a/src/analyse/Utils.ml b/src/analyse/Utils.ml
index cf316505..bcd5a717 100644
--- a/src/analyse/Utils.ml
+++ b/src/analyse/Utils.ml
@@ -49,13 +49,18 @@ open Logs.Logger (struct
 end)
 
 (** TODO: Maybe just use Z.t everywhere (it's shorter) *)
-type natural = Nat_big_num.num
+type natural = Sym.t
 
 (** machine address *)
 type addr = natural
 
 (* hackishly mask out bigint conversion failure *)
-let pp_addr (a : natural) = try Ml_bindings.hex_string_of_big_int_pad8 a with Failure s -> let s' = "Failure: int64_of_big_int " ^ Nat_big_num.to_string a in (warn "pp_addr failure: %s" s); s'| e -> raise e
+let pp_addr (a : natural) = 
+  try
+    Dwarf.pp_sym Ml_bindings.hex_string_of_big_int_pad8 a
+  with
+  | Failure s -> let s' = "Failure: int64_of_big_int " ^ Sym.to_string a in (warn "pp_addr failure: %s" s); s'
+  | e -> raise e
 
 (** index into instruction-indexed arrays *)
 type index = int
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
index bb2ecd56..3f584582 100644
--- a/src/utils/sym.ml
+++ b/src/utils/sym.ml
@@ -1,3 +1,18 @@
 type t = Z.t Dwarf.sym0
 
-let to_int x = Z.to_int @@ Dwarf.sym_unwrap x "to_int"
\ No newline at end of file
+let to_int x = Z.to_int @@ Dwarf.sym_unwrap x "to_int"
+
+let of_int x = Dwarf.Absolute (Z.of_int x)
+
+let equal = Dwarf.sym_comp Nat_big_num.equal
+let less = Dwarf.sym_comp Nat_big_num.less
+let less_equal = Dwarf.sym_comp Nat_big_num.less_equal
+let greater = Dwarf.sym_comp Nat_big_num.greater
+let greater_equal = Dwarf.sym_comp Nat_big_num.greater_equal
+
+let to_string = Dwarf.pp_sym Z.to_string
+
+let sub x y = match (x, y) with
+| (Dwarf.Offset (s, a), Dwarf.Offset (t, b)) when s = t -> Nat_big_num.sub a b
+| (Dwarf.Absolute a, Dwarf.Absolute b) -> Nat_big_num.sub a b
+| _ -> failwith "Can't compare"
\ No newline at end of file

From 14242979a366c234f8dd7fe3f598b12cbb3abe18 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 27 Jan 2025 13:46:23 +0000
Subject: [PATCH 040/116] [wip] symbolic analyse

---
 src/analyse/ControlFlow.ml      |  2 +-
 src/analyse/ControlFlowPpDot.ml |  6 +-
 src/analyse/DwarfVarInfo.ml     |  2 +-
 src/analyse/Elf.ml              | 98 +++++++++++++++------------------
 src/analyse/ElfSymbols.ml       |  4 +-
 src/analyse/ElfTypes.ml         |  3 +-
 src/analyse/Pp.ml               |  8 +--
 src/analyse/Symbols.ml          | 70 +++++++++++++++++++++++
 src/bin/copySources.ml          |  2 +-
 src/elf/file.ml                 |  2 +-
 src/utils/sym.ml                | 22 +++++++-
 11 files changed, 148 insertions(+), 71 deletions(-)
 create mode 100644 src/analyse/Symbols.ml

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 89bc11f6..578279cf 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -142,7 +142,7 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
   let rodata_words : (natural * natural) list = Dwarf.words_of_rel_byte_sequence rodata_addr (Dwarf.rbs_no_reloc bs) [] in (*HACK*)
 
   let read_rodata_b addr =
-    Elf_types_native_uint.natural_of_byte
+    Dwarf.sym_natural_of_byte
       rodata_bytes.(Sym.to_int (Sym.sub addr rodata_addr))
   in
   let read_rodata_h addr =
diff --git a/src/analyse/ControlFlowPpDot.ml b/src/analyse/ControlFlowPpDot.ml
index 77375477..123c0c04 100644
--- a/src/analyse/ControlFlowPpDot.ml
+++ b/src/analyse/ControlFlowPpDot.ml
@@ -204,7 +204,7 @@ let inlining_stack_at_index (an : analysis) k =
               (function
                 | sss' ->
                     String.concat "\n---\n"
-                      (List.map (Dwarf.pp_sdt_subroutine (Sym.of_int 0)) sss'))
+                      (List.map (Dwarf.pp_sdt_subroutine (Nat_big_num.of_int 0)) sss'))
               maximal));
       []
 
@@ -859,12 +859,12 @@ let mk_cfg test an visitedo node_name_prefix (recurse_flat : bool) (_inline_all
                       match new_ss_O2_ambient_option with
                       | None ->
                           fatal "no call site for\n%s"
-                            (Dwarf.pp_sdt_subroutine (Sym.of_int 0) ss_current)
+                            (Dwarf.pp_sdt_subroutine (Nat_big_num.of_int 0) ss_current)
                       | Some new_ss_O2_ambient -> (
                           match new_ss_O2_ambient.ss_call_site with
                           | None ->
                               fatal "no call site2 for\n%s"
-                                (Dwarf.pp_sdt_subroutine (Sym.of_int 0) ss_current)
+                                (Dwarf.pp_sdt_subroutine (Nat_big_num.of_int 0) ss_current)
                           | Some (_ufe, line, _subprogram_name) -> line
                         )
                       (*,
diff --git a/src/analyse/DwarfVarInfo.ml b/src/analyse/DwarfVarInfo.ml
index 54e2964f..144e48b5 100644
--- a/src/analyse/DwarfVarInfo.ml
+++ b/src/analyse/DwarfVarInfo.ml
@@ -246,7 +246,7 @@ let pp_ranged_var (prefix : string) (var : ranged_var) : string =
   let ((n1, n2, ops), (svfp, context)) = var in
   prefix
   ^ pp_sdt_concise_variable_or_formal_parameter_main 0 svfp
-  ^ (let s = Dwarf.pp_parsed_single_location_description (Sym.of_int 0) (n1, n2, ops) in
+  ^ (let s = Dwarf.pp_parsed_single_location_description (Nat_big_num.of_int 0) (n1, n2, ops) in
      String.sub s 0 (String.length s - 1))
   (*hackish stripping of trailing \n from linksem - TODO: fix linksem interface*)
   ^ " "
diff --git a/src/analyse/Elf.ml b/src/analyse/Elf.ml
index 0734c459..5b3bb63c 100644
--- a/src/analyse/Elf.ml
+++ b/src/analyse/Elf.ml
@@ -69,20 +69,23 @@ let pp_symbol_map (symbol_map : Elf_file.global_symbol_init_info) =
 
 let parse_elf_file (filename : string) : test =
   (* call ELF analyser on file *)
-  let info = Sail_interface.populate_and_obtain_global_symbol_init_info filename in
-
-  let ( (elf_file : Elf_file.elf_file),
-        (elf_epi : Sail_interface.executable_process_image),
-        (symbol_map : Elf_file.global_symbol_init_info) ) =
-    match info with
-    | Error.Fail s -> fatal "populate_and_obtain_global_symbol_init_info: %s" s
+  let bs = match Byte_sequence.acquire filename with
+    | Error.Fail s -> fatal "Linksem: Byte_sequence.acquire: %s" s
     | Error.Success x -> x
   in
-
-  let f64 =
-    match elf_file with Elf_file.ELF_File_64 f -> f | _ -> raise (Failure "not Elf64")
+  let f64 = match Elf_file.read_elf64_file bs with
+    | Error.Fail s -> fatal "Linksem: read_elf64_file: %s" s
+    | Error.Success x -> x
   in
+  let symbol_map = match Symbols.get_elf64_file_global_symbol_init f64 with
+    | Error.Fail s -> fatal "LinksemRelocatable: get_elf64_file_global_symbol_init: %s" s
+    | Error.Success x -> x
+  in
+
+  let elf_file = Elf_file.ELF_File_64 f64 in
 
+  let entry = f64.elf64_file_header.elf64_entry in
+  let machine = f64.elf64_file_header.elf64_machine in
   (* linksem main_elf --symbols looks ok for gcc and clang
 
      That uses                 Elf_file.read_elf64_file bs0 >>= fun f1 ->
@@ -125,49 +128,38 @@ let parse_elf_file (filename : string) : test =
  *)
 
   (*  Debug.print_string "elf segments etc\n";*)
-  match (elf_epi, elf_file) with
-  | (Sail_interface.ELF_Class_32 _, _) -> fatal "%s" "cannot handle ELF_Class_32"
-  | (_, Elf_file.ELF_File_32 _) -> fatal "%s" "cannot handle ELF_File_32"
-  | (Sail_interface.ELF_Class_64 (segments, e_entry, e_machine), Elf_file.ELF_File_64 f1) ->
-      (* architectures from linksem elf_header.lem *)
-      let arch =
-        if f64.elf64_file_header.elf64_machine = Elf_header.elf_ma_aarch64 then AArch64
-        else if f64.elf64_file_header.elf64_machine = Elf_header.elf_ma_x86_64 then X86
-        else fatal "unrecognised ELF file architecture"
-      in
-
-      (* remove all the auto generated segments (they contain only 0s) *)
-      let segments =
-        Lem_list.mapMaybe
-          (fun (seg, prov) -> if prov = Elf_file.FromELF then Some seg else None)
-          segments
-      in
-      let ds =
-        match Dwarf.extract_dwarf_static (Elf_file.ELF_File_64 f1) Abi_aarch64_symbolic_relocation.aarch64_data_relocation_interpreter with
-        | None -> fatal "%s" "extract_dwarf_static failed"
-        | Some ds ->
-            (* Debug.print_string2 (Dwarf.pp_analysed_location_data ds.Dwarf.ds_dwarf
-                                      ds.Dwarf.ds_analysed_location_data);
-               Debug.print_string2 (Dwarf.pp_evaluated_frame_info
-                                      ds.Dwarf.ds_evaluated_frame_info);*)
-            ds
-      in
-      let dwarf_semi_pp_frame_info =
-        Dwarf.semi_pp_evaluated_frame_info ds.ds_evaluated_frame_info
-      in
-      let test =
-        {
-          elf_file;
-          arch;
-          symbol_map (*@ (symbols_for_stacks !Globals.elf_threads)*);
-          segments;
-          e_entry;
-          e_machine;
-          dwarf_static = ds;
-          dwarf_semi_pp_frame_info;
-        }
-      in
-      test
+    (* architectures from linksem elf_header.lem *)
+    let arch =
+      if f64.elf64_file_header.elf64_machine = Elf_header.elf_ma_aarch64 then AArch64
+      else if f64.elf64_file_header.elf64_machine = Elf_header.elf_ma_x86_64 then X86
+      else fatal "unrecognised ELF file architecture"
+    in
+
+    let ds =
+      match Dwarf.extract_dwarf_static (Elf_file.ELF_File_64 f64) Abi_aarch64_symbolic_relocation.aarch64_data_relocation_interpreter with
+      | None -> fatal "%s" "extract_dwarf_static failed"
+      | Some ds ->
+          (* Debug.print_string2 (Dwarf.pp_analysed_location_data ds.Dwarf.ds_dwarf
+                                    ds.Dwarf.ds_analysed_location_data);
+              Debug.print_string2 (Dwarf.pp_evaluated_frame_info
+                                    ds.Dwarf.ds_evaluated_frame_info);*)
+          ds
+    in
+    let dwarf_semi_pp_frame_info =
+      Dwarf.semi_pp_evaluated_frame_info ds.ds_evaluated_frame_info
+    in
+    let test =
+      {
+        elf_file;
+        arch;
+        symbol_map (*@ (symbols_for_stacks !Globals.elf_threads)*);
+        e_entry = Dwarf.Absolute (entry);
+        e_machine = Dwarf.Absolute (machine);
+        dwarf_static = ds;
+        dwarf_semi_pp_frame_info;
+      }
+    in
+    test
 
 (*****************************************************************************)
 (**       marshal and unmarshal test                                         *)
diff --git a/src/analyse/ElfSymbols.ml b/src/analyse/ElfSymbols.ml
index 83a526ea..e74f7aeb 100644
--- a/src/analyse/ElfSymbols.ml
+++ b/src/analyse/ElfSymbols.ml
@@ -54,7 +54,7 @@ open ControlFlowTypes
 let elf_symbols_of_address (test : test) (addr : natural) : string list =
   List.filter_map
     (fun (name, (_typ, _size, address, _mb, _binding)) ->
-      if Dwarf.Absolute address = addr then Some name else None)
+      if address = addr then Some name else None)
     test.symbol_map
 
 let mk_elf_symbols test instructions : string list array =
@@ -62,5 +62,5 @@ let mk_elf_symbols test instructions : string list array =
 
 let address_of_elf_symbol test (s : string) : addr option =
   List.find_map
-    (fun (name, (_typ, _size, address, _mb, _binding)) -> if s = name then Some (Dwarf.Absolute address) else None)
+    (fun (name, (_typ, _size, address, _mb, _binding)) -> if s = name then Some address else None)
     test.symbol_map
diff --git a/src/analyse/ElfTypes.ml b/src/analyse/ElfTypes.ml
index a0795eb0..005a7ba6 100644
--- a/src/analyse/ElfTypes.ml
+++ b/src/analyse/ElfTypes.ml
@@ -62,8 +62,7 @@ type architecture =
 type test = {
   elf_file : Elf_file.elf_file;
   arch : architecture;
-  symbol_map : Elf_file.global_symbol_init_info;
-  segments : Elf_interpreted_segment.elf64_interpreted_segment list;
+  symbol_map : Symbols.global_symbol_init_info;
   e_entry : natural;
   e_machine : natural;
   dwarf_static : Dwarf.dwarf_static;
diff --git a/src/analyse/Pp.ml b/src/analyse/Pp.ml
index 87ce1bec..9dbf2b7a 100644
--- a/src/analyse/Pp.ml
+++ b/src/analyse/Pp.ml
@@ -619,7 +619,7 @@ let chunks_of_ranged_cu m test an filename_stem ((low, high), cu) =
           pp_abbreviations_table cu'.cu_abbreviations_table );
         ( "die",
           ".debug_info die tree",
-          pp_die c cu'.cu_header d.d_str true (*indent*) (Sym.of_int 0) true cu'.cu_die );
+          pp_die c cu'.cu_header d.d_str true (*indent*) (Nat_big_num.of_int 0) true cu'.cu_die );
         ( "line",
           ".debug_line line number info",
           let lnp = line_number_program_of_compilation_unit d cu' in
@@ -628,13 +628,13 @@ let chunks_of_ranged_cu m test an filename_stem ((low, high), cu) =
           ".debug_line evaluated line info",
           let lnrs = evaluated_line_info_of_compilation_unit d cu' ds.ds_evaluated_line_info in
           pp_line_number_registerss lnrs );
-        ("sdt", "simple die tree", pp_sdt_compilation_unit (Sym.of_int 0) cu);
+        ("sdt", "simple die tree", pp_sdt_compilation_unit (Nat_big_num.of_int 0) cu);
         ( "sdt_globals",
           "simple die tree globals",
-          pp_sdt_globals_compilation_unit (Sym.of_int 0) cu );
+          pp_sdt_globals_compilation_unit (Nat_big_num.of_int 0) cu );
         ( "sdt_locals",
           "simple die tree locals",
-          pp_sdt_locals_compilation_unit (Sym.of_int 0) cu );
+          pp_sdt_locals_compilation_unit (Nat_big_num.of_int 0) cu );
         ("inlined", "inlined subroutine info", pp_inlined_subroutines ds iss);
         ( "inlined_by_range",
           "inlined subroutine info by range",
diff --git a/src/analyse/Symbols.ml b/src/analyse/Symbols.ml
new file mode 100644
index 00000000..360ffbf6
--- /dev/null
+++ b/src/analyse/Symbols.ml
@@ -0,0 +1,70 @@
+(* TODO header *)
+
+module SMap = Map.Make (String)
+
+type rels =
+  | AArch64 of (Z.t, Abi_aarch64_symbolic_relocation.aarch64_relocation_target Elf_symbolic.abstract_relocation) Pmap.map
+
+type sym_data =
+Byte_sequence_wrapper.byte_sequence * rels
+
+
+(* Like in linksem, but address is section+offset, data has relocations and with a writable flag *)
+type symbol = string * (Z.t * Z.t * Sym.t * sym_data * Z.t)
+
+type global_symbol_init_info = symbol list
+
+open Elf_symbol_table
+open Elf_interpreted_section
+
+let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_init_info Error.error =
+  let secs = f.elf64_file_interpreted_sections in
+  let machine = f.elf64_file_header.elf64_machine in
+  Error.bind (Elf_file.get_elf64_file_symbol_table f) @@ fun (symtab, strtab) ->
+    let rel_cache = ref SMap.empty in
+    let get_relocs section =
+      match SMap.find_opt section !rel_cache with
+      | Some rels -> rels
+      | None ->
+        if machine = Elf_header.elf_ma_aarch64 then
+          Error.bind
+            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.abi_aarch64_relocation_to_abstract section)
+            @@ fun relocs -> Error.return (AArch64 relocs)
+        else
+          Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
+    in
+    List.filter_map (
+      fun entry ->
+        let name = Uint32_wrapper.to_bigint entry.elf64_st_name in
+        let addr_offset = Uint64_wrapper.to_bigint entry.elf64_st_value in
+        let size = Uint64_wrapper.to_bigint entry.elf64_st_size in
+        let shndx = Uint32_wrapper.to_int entry.elf64_st_shndx in
+        let typ  = Elf_symbol_table.extract_symbol_type entry.elf64_st_info in
+        let bnd  = Elf_symbol_table.extract_symbol_binding entry.elf64_st_info in
+        Option.map (
+          fun section ->
+            let addr = Dwarf.Offset (section.elf64_section_name_as_string, addr_offset) in
+            let data = if Byte_sequence.length0 section.elf64_section_body = Z.zero then
+              Error.return (Byte_sequence.zeros size)
+            else
+              Byte_sequence.offset_and_cut addr_offset size section.elf64_section_body
+            in
+            Error.bind (get_relocs section.elf64_section_name_as_string) @@ fun (AArch64 relocs) ->
+              let relocs = relocs
+              |> Pmap.bindings_list
+              |> List.fold_left (fun m (pos, r) ->
+                  let sz = size in
+                  let open Z in
+                  let open Compare in
+                  if pos >= addr_offset && pos < addr_offset + sz then
+                    Pmap.add (pos - addr_offset) r m
+                  else
+                    m
+                ) (Pmap.empty Z.compare)
+              |> fun x -> AArch64 x
+              in
+            Error.bind data @@ fun data ->
+              Error.bind (String_table.get_string_at name strtab) @@ fun str ->
+              Error.return (str, (typ, size, addr, (data, relocs), bnd))
+        ) (List.nth_opt secs shndx)
+    ) symtab |> Error.mapM Fun.id
\ No newline at end of file
diff --git a/src/bin/copySources.ml b/src/bin/copySources.ml
index 094d3257..dc30fd01 100644
--- a/src/bin/copySources.ml
+++ b/src/bin/copySources.ml
@@ -79,7 +79,7 @@ let process_file () : unit =
       (function
         | lnfe ->
             ( lnh.lnh_comp_dir,
-              (let dir = Nat_big_num.to_int lnfe.lnfe_directory_index in
+              (let dir = Sym.to_int lnfe.lnfe_directory_index in
                if dir = 0 then None
                else
                  Some
diff --git a/src/elf/file.ml b/src/elf/file.ml
index e3d8925d..1b2f39fc 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -145,7 +145,7 @@ let of_file (filename : string) =
     Segment.
       {
         data;
-        addr = Nat_big_num.to_int addr;
+        addr = Sym.to_int addr; (* TODO *)
         size = BytesSeq.length data;
         read = true;
         write = false;
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
index 3f584582..910c0b1c 100644
--- a/src/utils/sym.ml
+++ b/src/utils/sym.ml
@@ -3,16 +3,32 @@ type t = Z.t Dwarf.sym0
 let to_int x = Z.to_int @@ Dwarf.sym_unwrap x "to_int"
 
 let of_int x = Dwarf.Absolute (Z.of_int x)
+let of_int64 x = Dwarf.Absolute (Z.of_int64 x)
 
 let equal = Dwarf.sym_comp Nat_big_num.equal
 let less = Dwarf.sym_comp Nat_big_num.less
 let less_equal = Dwarf.sym_comp Nat_big_num.less_equal
 let greater = Dwarf.sym_comp Nat_big_num.greater
 let greater_equal = Dwarf.sym_comp Nat_big_num.greater_equal
+let compare = Dwarf.sym_comp Nat_big_num.compare
 
 let to_string = Dwarf.pp_sym Z.to_string
 
 let sub x y = match (x, y) with
-| (Dwarf.Offset (s, a), Dwarf.Offset (t, b)) when s = t -> Nat_big_num.sub a b
-| (Dwarf.Absolute a, Dwarf.Absolute b) -> Nat_big_num.sub a b
-| _ -> failwith "Can't compare"
\ No newline at end of file
+| (Dwarf.Offset (s, a), Dwarf.Offset (t, b)) when s = t -> Dwarf.Absolute (Nat_big_num.sub a b)
+| (Dwarf.Absolute a, Dwarf.Absolute b) -> Dwarf.Absolute (Nat_big_num.sub a b)
+| _ -> Dwarf.Unknown
+
+let add x y = match (x, y) with
+| (Dwarf.Offset (s, a), Dwarf.Absolute b) -> Dwarf.Offset (s, Nat_big_num.add a b)
+| (Dwarf.Absolute (a), Dwarf.Offset (s,b)) -> Dwarf.Offset (s, Nat_big_num.add a b)
+| (Dwarf.Absolute a, Dwarf.Absolute b) -> Dwarf.Absolute (Nat_big_num.add a b)
+| _ -> Dwarf.Unknown
+
+let mul = Dwarf.sym_map2 Nat_big_num.mul
+
+let pow_int_positive x y = Dwarf.Absolute (Nat_big_num.pow_int_positive x y)
+
+let shift_left x s = Dwarf.sym_map (fun x -> Nat_big_num.shift_left x s) x
+let shift_right x s = Dwarf.sym_map (fun x -> Nat_big_num.shift_right x s) x
+let modulus = Dwarf.sym_map2 Nat_big_num.modulus
\ No newline at end of file

From 1d1611ff45d7b1b3b76e788ee55a8bec8a5f25a5 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 27 Jan 2025 18:16:33 +0000
Subject: [PATCH 041/116] [wip] symbolic analyse

---
 src/analyse/ControlFlow.ml   | 35 ++++++++++++++++++++++++-----------
 src/analyse/DwarfLineInfo.ml |  3 ++-
 src/analyse/Pp.ml            |  7 +++----
 src/utils/sym.ml             | 24 ++++++++++++++++++++++--
 4 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 578279cf..2bcc4c4b 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -440,12 +440,21 @@ AArch64:
 let objdump_line_regexp =
   Str.regexp " *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\) *\\(.*\\)$"
 
+let section_start_line_regexp =
+  Str.regexp "Disassembly of section \\(.*\\):$"
+
 type objdump_instruction =
   natural (*address*) * int list (*opcode bytes*) * string (*mnemonic*) * string
 
 (*args etc*)
 
-let parse_objdump_line (s : string) : objdump_instruction option =
+let parse_section_start s =
+  if Str.string_match section_start_line_regexp s 0 then
+    Some (Str.matched_group 1 s)
+  else
+    None
+
+let parse_objdump_line (s : string) : (int64 * int list * string * string) option =
   let parse_hex_int64 s' =
     try Scanf.sscanf s' "%Lx" (fun i64 -> i64)
     with _ -> fatal "cannot parse address in objdump line %s\n" s
@@ -465,7 +474,6 @@ let parse_objdump_line (s : string) : objdump_instruction option =
   if Str.string_match objdump_line_regexp s 0 then
     begin
       let addr_int64 = parse_hex_int64 (Str.matched_group 1 s) in
-      let addr = Sym.of_int64 addr_int64 in
       let op = Str.matched_group 2 s in
       let op = strip_whitespace op in
       let opcode_byte_strings =
@@ -477,7 +485,7 @@ let parse_objdump_line (s : string) : objdump_instruction option =
       let opcode_bytes = List.map parse_hex_int opcode_byte_strings in
       let mnemonic = Str.matched_group 3 s in
       let operands = Str.matched_group 4 s in
-      Some (addr, opcode_bytes, mnemonic, operands)
+      Some (addr_int64, opcode_bytes, mnemonic, operands)
     end
   else None
 
@@ -486,30 +494,35 @@ let parse_objdump_lines arch lines : objdump_instruction list =
   List.filter_map (parse_objdump_line arch) (Array.to_list lines)
  *)
 
-let rec parse_objdump_lines arch lines (next_index : int) (last_address : natural option) :
+let with_symbolic_address (section: string) (addr, opcode_bytes, mnemonic, operands) : objdump_instruction =
+  (Dwarf.Offset (section, Nat_big_num.of_int64 addr), opcode_bytes, mnemonic, operands)
+
+let rec parse_objdump_lines arch lines (next_index : int) (last_address : int64 option) (section: string option) :
     objdump_instruction list =
   if next_index >= Array.length lines then []
   else
+    let section = Option.fold ~none:section ~some:Option.some @@ parse_section_start lines.(next_index) in
     match parse_objdump_line lines.(next_index) with
     (* skip over unparseable lines *)
-    | None -> parse_objdump_lines arch lines (next_index + 1) last_address
+    | None -> parse_objdump_lines arch lines (next_index + 1) last_address section
     | Some ((addr, _opcode_bytes, _mnemonic, _operands) as i) -> (
+        let mki = with_symbolic_address (Option.get section) in
         match last_address with
-        | None -> i :: parse_objdump_lines arch lines (next_index + 1) (Some addr)
+        | None -> mki i :: parse_objdump_lines arch lines (next_index + 1) (Some addr) section
         | Some last_address' ->
-            let last_address'' = Sym.add last_address' (Sym.of_int 4) in
+            let last_address'' = Int64.add last_address' (Int64.of_int 4) in
             if addr > last_address'' then
               (* fake up "missing" instructions for any gaps in the address space*)
               (*warn "gap in objdump instruction address sequence at %s" (pp_addr last_address'');*)
-              (last_address'', [], "missing", "")
-              :: parse_objdump_lines arch lines next_index (Some last_address'')
-            else i :: parse_objdump_lines arch lines (next_index + 1) (Some addr)
+              mki (last_address'', [], "missing", "")
+              :: parse_objdump_lines arch lines next_index (Some last_address'') section
+            else mki i :: parse_objdump_lines arch lines (next_index + 1) (Some addr) section
       )
 
 let parse_objdump_file arch filename_objdump_d : objdump_instruction array =
   match read_file_lines filename_objdump_d with
   | Error s -> fatal "%s\ncouldn't read objdump-d file: \"%s\"\n" s filename_objdump_d
-  | Ok lines -> Array.of_list (parse_objdump_lines arch lines 0 None)
+  | Ok lines -> Array.of_list (parse_objdump_lines arch lines 0 None None)
 
 (*****************************************************************************)
 (**  parse control-flow instruction asm from objdump and branch table data   *)
diff --git a/src/analyse/DwarfLineInfo.ml b/src/analyse/DwarfLineInfo.ml
index b3561313..7cb6bf73 100644
--- a/src/analyse/DwarfLineInfo.ml
+++ b/src/analyse/DwarfLineInfo.ml
@@ -136,6 +136,7 @@ let split_into_sequences
             | None -> fatal "split_into_sequences found sequence of length 0"
           in
           let last = lnr.lnr_address in
+          (* print_endline (Dwarf.pphex_sym first ^ " " ^ Dwarf.pphex_sym last); *)
           if Sym.equal first last then fatal "split_into_sequences found first=last"
           else ();
           let elis =
@@ -293,7 +294,7 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
       let (new_perhaps_relevant, remaining') = mk_new_perhaps_relevant [] remaining_entries in
 
       let addr_in elie =
-        Sym.less_equal elie.elie_first addr && Sym.less_equal addr elie.elie_last
+        Sym.in_range elie.elie_first elie.elie_last addr
       in
 
       let still_active_entries =
diff --git a/src/analyse/Pp.ml b/src/analyse/Pp.ml
index 9dbf2b7a..0bf41866 100644
--- a/src/analyse/Pp.ml
+++ b/src/analyse/Pp.ml
@@ -857,7 +857,6 @@ let pp_test_analysis m test an =
       call_graph ^ "* ************* transitive call graph **************\n"
       ^ transitive_call_graph
   | Html ->
-     ""
-     (* "\n* ************* instructions *****************\n" *)
-       (*pp_instruction_init ();
-      String.concat "" (Array.to_list (Array.mapi (pp_instruction m test an 0) an.instructions))*)
+     "\n* ************* instructions *****************\n"
+     ^ (pp_instruction_init ();
+      String.concat "" (Array.to_list (Array.mapi (pp_instruction m test an 0) an.instructions)))
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
index 910c0b1c..839f5c96 100644
--- a/src/utils/sym.ml
+++ b/src/utils/sym.ml
@@ -1,12 +1,25 @@
 type t = Z.t Dwarf.sym0
 
+let pp x = x |> Dwarf.pphex_sym |> Pp.string
+
 let to_int x = Z.to_int @@ Dwarf.sym_unwrap x "to_int"
 
 let of_int x = Dwarf.Absolute (Z.of_int x)
 let of_int64 x = Dwarf.Absolute (Z.of_int64 x)
 
 let equal = Dwarf.sym_comp Nat_big_num.equal
-let less = Dwarf.sym_comp Nat_big_num.less
+
+let max_addr = Z.(shift_left (of_int 1) 64 - (of_int 1))
+
+let min_addr = Z.of_int 0
+
+(* TODO very hacky *)
+let less x y = match (x, y) with
+| (Dwarf.Absolute x, Dwarf.Offset (_, y)) when Nat_big_num.less x y -> true
+| (Dwarf.Absolute x, Dwarf.Offset (_,_)) when Nat_big_num.greater_equal x max_addr -> false
+| (Dwarf.Offset (_,_), Dwarf.Absolute y) when Nat_big_num.less max_addr y -> true
+| (Dwarf.Offset (_, x), Dwarf.Absolute y) when Nat_big_num.greater_equal x y -> false
+| _ -> Dwarf.sym_comp Nat_big_num.less x y
 let less_equal = Dwarf.sym_comp Nat_big_num.less_equal
 let greater = Dwarf.sym_comp Nat_big_num.greater
 let greater_equal = Dwarf.sym_comp Nat_big_num.greater_equal
@@ -16,6 +29,7 @@ let to_string = Dwarf.pp_sym Z.to_string
 
 let sub x y = match (x, y) with
 | (Dwarf.Offset (s, a), Dwarf.Offset (t, b)) when s = t -> Dwarf.Absolute (Nat_big_num.sub a b)
+| (Dwarf.Offset (s, a), Dwarf.Absolute b) -> Dwarf.Offset (s, Nat_big_num.sub a b)
 | (Dwarf.Absolute a, Dwarf.Absolute b) -> Dwarf.Absolute (Nat_big_num.sub a b)
 | _ -> Dwarf.Unknown
 
@@ -31,4 +45,10 @@ let pow_int_positive x y = Dwarf.Absolute (Nat_big_num.pow_int_positive x y)
 
 let shift_left x s = Dwarf.sym_map (fun x -> Nat_big_num.shift_left x s) x
 let shift_right x s = Dwarf.sym_map (fun x -> Nat_big_num.shift_right x s) x
-let modulus = Dwarf.sym_map2 Nat_big_num.modulus
\ No newline at end of file
+let modulus = Dwarf.sym_map2 Nat_big_num.modulus
+
+let in_range first last x = match (first, last, x) with
+| (Dwarf.Absolute f, Dwarf.Absolute l, Dwarf.Absolute x) -> Nat_big_num.less_equal f x && Nat_big_num.less_equal x l
+| (Dwarf.Offset (s1, f), Dwarf.Offset (s2, l), Dwarf.Offset (s, x)) when s1 = s2 ->
+  s1 = s && Nat_big_num.less_equal f x && Nat_big_num.less_equal x l (* TODO kinda hacky *)
+| _ -> Raise.fail "Can't determine if %t is in range [%t,%t]" (Pp.tos pp x) (Pp.tos pp first) (Pp.tos pp last)
\ No newline at end of file

From 04ee90ef6985ffc26f15d18f29611cd946146832 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 27 Jan 2025 23:53:21 +0000
Subject: [PATCH 042/116] Fix parsing objdump

---
 src/analyse/ControlFlow.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 2bcc4c4b..4c305098 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -291,7 +291,7 @@ let parse_addr (s : string) : natural =
 try 
   Scanf.sscanf s "0x%Lx" (fun i64 -> Sym.of_int64 i64)
 with
-  Scanf.Scan_failure _  ->
+  (Scanf.Scan_failure _ | End_of_file)  ->
    Scanf.sscanf s "%Lx" (fun i64 -> Sym.of_int64 i64)
 
 let parse_target s =

From 5d010309d195e27241d7186e22a46c037e727012 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 30 Jan 2025 13:06:17 +0000
Subject: [PATCH 043/116] notes

---
 notes-TODO | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/notes-TODO b/notes-TODO
index b1a58b67..95c382c0 100644
--- a/notes-TODO
+++ b/notes-TODO
@@ -6,4 +6,17 @@ Instruction fetch: is it sound? (rewriting .text)
 
 Z3 finding unique solution
 - Get model -> assert not model -> check now it is unsat
-- Need to extend the protocol probably
\ No newline at end of file
+- Need to extend the protocol probably
+
+SIMREL
+- state = (pc,M) (and registers TODO)
+- (pc,M1) ~ (pc.M2) iff there is MT, such that
+    MT(A1,A2,sz) = T => M1[A1:A1+sz] =T M2[A2:A2+sz]
+    and respects dwarf at pc
+    and maybe some consistency of MT?? e.g. overlaping ranges
+- relation (=T) defined using MT
+    - (=base_type) is equality
+    - (=struct) fieldwise
+    - (=*T):
+        A1 =*T A2 <=> MT(A1,A2,sz(T)) = T
+- Hoare logic (or similar) with MT as variable (only read/write commands)

From 65ebed5aca0933d92e983ca08b6fcab7e03d5db4 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 30 Jan 2025 13:10:22 +0000
Subject: [PATCH 044/116] set SCTLR_EL2

---
 src/config/isla_aarch64.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/config/isla_aarch64.toml b/src/config/isla_aarch64.toml
index 27d6e500..f762a682 100644
--- a/src/config/isla_aarch64.toml
+++ b/src/config/isla_aarch64.toml
@@ -141,6 +141,7 @@ ignore = [
 # Bit 1 being unset allows unaligned accesses
 # Bit 26 being set allows cache-maintenance ops in EL0
 "SCTLR_EL1" = "0x0000000004000000"
+"SCTLR_EL2" = "0x0000000004000000"
 
 # A map from register names that may appear in litmus files to Sail
 # register names

From d30207dc5a408771da53d1576d342e4cbe71cb21 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 30 Jan 2025 13:53:32 +0000
Subject: [PATCH 045/116] Make funcRD work

---
 src/bin/readDwarf.ml |  2 +-
 src/elf/address.ml   |  2 ++
 src/run/funcRD.ml    | 38 +++++++++++++++++++++++---------------
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/src/bin/readDwarf.ml b/src/bin/readDwarf.ml
index 6be5927f..53e15618 100644
--- a/src/bin/readDwarf.ml
+++ b/src/bin/readDwarf.ml
@@ -71,7 +71,7 @@ let commands =
     Run.Func.command;
     Run.Instr.command;
     Run.Block.command;
-    (* Run.FuncRD.command; *)
+    Run.FuncRD.command;
     CopySourcesCmd.command;
     Z3.Test.command;
   ]
diff --git a/src/elf/address.ml b/src/elf/address.ml
index 701ddd89..f332f31a 100644
--- a/src/elf/address.ml
+++ b/src/elf/address.ml
@@ -22,3 +22,5 @@ let (>) = compare (>)
 let (<=) = compare (<=)
 
 let (>=) = compare (>=)
+
+let to_sym {section; offset} = Dwarf.Offset (section, Z.of_int offset)
\ No newline at end of file
diff --git a/src/run/funcRD.ml b/src/run/funcRD.ml
index 374b7e9d..f2d1fffb 100644
--- a/src/run/funcRD.ml
+++ b/src/run/funcRD.ml
@@ -48,14 +48,18 @@
     instructions.*)
 
 open Cmdliner
-(* open Config.CommonOpt *)
-(* open Fun *)
+open Config.CommonOpt
+open Fun
 
 open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-(* let run_func_rd elfname name objdump_d branchtables breakpoints =
+let run_func_rd elfname name objdump_d branchtables breakpoints =
+  match Analyse.Utils.read_file_lines "src/analyse/html-preamble-insts.html" with
+  | Error _ -> ()
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
+  ;
   base "Running with rd %s in %s" name elfname;
   base "Loading %s" elfname;
   let dwarf = Dw.of_file elfname in
@@ -70,13 +74,13 @@ end)
   let abi = Arch.get_abi api in
   Trace.Cache.start @@ Arch.get_isla_config ();
   base "Computing entry state";
-  let start = Init.state () |> State.copy ~elf |> abi.init in
+  let start = Init.state () |> State.copy ~elf |> State.init_sections ~addr_size:Arch.address_size |> abi.init in
   base "Loading %s for Analyse" elfname;
   let analyse_test = Analyse.Elf.parse_elf_file elfname in
   base "Analysing %s for Analyse" elfname;
   let analyse_analysis = Analyse.Collected.mk_analysis analyse_test objdump_d branchtables in
   let print_analyse_instruction pc =
-    let pc = Z.of_int pc in
+    let pc = Elf.Address.to_sym pc in
     let index = analyse_analysis.index_of_address pc in
     let instr = analyse_analysis.instructions.(index) in
     Analyse.Pp.pp_instruction Analyse.Types.Html (*Ascii*) analyse_test analyse_analysis 0 index
@@ -98,7 +102,7 @@ end)
       let tree = Block_lib.run ~every_instruction:true block start in
       base "Ended running, start pretty printing";
       (* This table will contain the state diff to print at each pc with a message *)
-      let instr_data : (int, string * State.t * State.Reg.t list) Hashtbl.t =
+      let instr_data : (Elf.Address.t, string * State.t * State.Reg.t list) Hashtbl.t =
         Hashtbl.create 100
       in
       let get_footprint pc =
@@ -113,7 +117,7 @@ end)
               let last_pc = st.last_pc in
               let last_instr_f = get_footprint last_pc in
               let s =
-                if last_pc <> pc - 4 then Printf.sprintf "Coming from 0x%x: " last_pc else ""
+                if Elf.Address.(last_pc + 4 <> pc) then Printf.sprintf "Coming from %t: " Pp.(tos Elf.Address.pp last_pc) else ""
               in
               let regs = List.merge_uniq Stdlib.compare cur_instr_f last_instr_f in
               Hashtbl.add instr_data pc (Printf.sprintf "%sBefore branch" s, st, regs)
@@ -122,27 +126,31 @@ end)
               let last_pc = st.last_pc in
               let last_instr_f = get_footprint last_pc in
               let s =
-                if last_pc <> pc - 4 then Printf.sprintf "Coming from 0x%x: " last_pc else ""
+                if Elf.Address.(last_pc + 4 <> pc) then Printf.sprintf "Coming from %t: " Pp.(tos Elf.Address.pp last_pc) else ""
               in
               let regs = List.merge_uniq Stdlib.compare cur_instr_f last_instr_f in
               Hashtbl.add instr_data pc (Printf.sprintf "%sNormal instruction" s, st, regs)
           | Block_lib.End s ->
               let last_pc = st.last_pc in
               let last_instr = Runner.expect_normal runner last_pc in
-              Hashtbl.add instr_data (st.last_pc + 4)
+              Hashtbl.add instr_data Elf.Address.(st.last_pc + 4)
                 (Printf.sprintf "End because: %s" s, st, Trace.Instr.footprint last_instr))
         tree;
       Vec.iter
         (fun funcaddr ->
           let sym = Elf.SymTable.of_addr elf.symbols funcaddr in
           Analyse.Pp.pp_instruction_init ();
-          Seq.iota_step_up ~start:funcaddr ~step:4 ~endi:(funcaddr + sym.size)
-          |> Seq.iter (fun pc ->
+          Seq.iota_step_up ~start:0 ~step:4 ~endi:sym.size
+          |> Seq.iter (fun pc_diff ->
+                let pc = Elf.Address.(funcaddr + pc_diff) in
                  Hashtbl.find_all instr_data pc
                  |> List.iter (fun (msg, st, regs) ->
-                        base "At 0x%x, %s:\n%t" pc msg Pp.(topi (State.pp_partial ~regs) st));
+                        base "At %t, %s:\n%t" Pp.(top Elf.Address.pp pc) msg Pp.(topi (State.pp_partial ~regs) st));
                  print_string (print_analyse_instruction pc)))
-        runner.funcs *)
+        runner.funcs; 
+  match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
+  | Error _ -> ()
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
 
 let elf =
   let doc = "ELF file from which to pull the code" in
@@ -168,7 +176,7 @@ let breakpoints =
   in
   Arg.(value & opt_all string [] & info ["b"; "break"] ~docv:"POSITION" ~doc)
 
-(* let term =
+let term =
   Term.(
     CmdlinerHelper.func_options comopts run_func_rd
     $ elf $ func $ objdump_d $ branch_table $ breakpoints)
@@ -181,4 +189,4 @@ let info =
   in
   Cmd.(info "run-func-rd" ~doc ~exits)
 
-let command = (term, info) *)
+let command = (term, info)

From b0dc540d6795bc61c126918cc6ec204d97728430 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 31 Jan 2025 15:20:47 +0000
Subject: [PATCH 046/116] Fix init of large objects

---
 src/elf/file.ml   |  1 +
 src/state/base.ml | 15 ++++++++++-----
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index 1b2f39fc..d628ed8f 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -142,6 +142,7 @@ let of_file (filename : string) =
       (* `false' argument is for returning an empty byte-sequence if
          section is not found, instead of throwing an exception *)
     in
+    Printf.printf "%t" Pp.(top Sym.pp addr);
     Segment.
       {
         data;
diff --git a/src/state/base.ml b/src/state/base.ml
index b6918d03..96e35997 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -533,11 +533,16 @@ let init_sections ~addr_size state =
     Elf.SymTable.iter elf.symbols @@ fun sym ->
       if sym.typ = Elf.Symbol.OBJECT then
         let provenance = Mem.create_section_frag ~addr_size state.mem sym.addr.section in
-        let addr = Exp.of_address ~size:addr_size sym.addr in
-        let size = Ast.Size.of_bytes sym.size in
-        let (exp, asserts) = Relocation.exp_of_data sym.data in
-        Mem.write ~provenance state.mem ~addr ~size ~exp;
-        List.iter (push_relocation_assert state) asserts;
+        Seq.iota_step_up ~step:16 ~endi:sym.size
+        |> Seq.iter (fun off ->
+          let len = min 16 (sym.size - off) in
+          let data = Elf.Symbol.sub sym off len in
+          let addr = Exp.of_address ~size:addr_size Elf.Address.(sym.addr + off) in
+          let size = Ast.Size.of_bytes len in
+          let (exp, asserts) = Relocation.exp_of_data data in
+          Mem.write ~provenance state.mem ~addr ~size ~exp;
+          List.iter (push_relocation_assert state) asserts;
+        )
   ) in
   state
 

From bda07fb41125359631d1f18e07eb7be184c7cffc Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 31 Jan 2025 16:05:25 +0000
Subject: [PATCH 047/116] [wip] Run program

---
 src/bin/readDwarf.ml |   1 +
 src/run/relProg.ml   | 109 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 110 insertions(+)
 create mode 100644 src/run/relProg.ml

diff --git a/src/bin/readDwarf.ml b/src/bin/readDwarf.ml
index 53e15618..60a7749f 100644
--- a/src/bin/readDwarf.ml
+++ b/src/bin/readDwarf.ml
@@ -72,6 +72,7 @@ let commands =
     Run.Instr.command;
     Run.Block.command;
     Run.FuncRD.command;
+    Run.RelProg.command;
     CopySourcesCmd.command;
     Z3.Test.command;
   ]
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
new file mode 100644
index 00000000..f2a3f202
--- /dev/null
+++ b/src/run/relProg.ml
@@ -0,0 +1,109 @@
+open Cmdliner
+open Config.CommonOpt
+
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
+
+let run_prog elfname name objdump_d branchtables =
+  match Analyse.Utils.read_file_lines "src/analyse/html-preamble-insts.html" with
+  | Error _ -> ()
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
+  ;
+  base "Running with rd %s in %s" name elfname;
+  base "Loading %s" elfname;
+  let dwarf = Dw.of_file elfname in
+  let elf = dwarf.elf in
+  let func =
+    Dw.get_func_opt ~name dwarf
+    |> Option.value_fun ~default:(fun () -> fail "Function %s wasn't found in %s" name elfname)
+  in
+  let api = Dw.Func.get_api func in
+  base "API %t" (Pp.top Arch.pp_api api);
+  base "Loading ABI";
+  let abi = Arch.get_abi api in
+  Trace.Cache.start @@ Arch.get_isla_config ();
+  base "Computing entry state";
+  let start = Init.state () |> State.copy ~elf |> State.init_sections ~addr_size:Arch.address_size |> abi.init in
+  base "Loading %s for Analyse" elfname;
+  let analyse_test = Analyse.Elf.parse_elf_file elfname in
+  base "Analysing %s for Analyse" elfname;
+  let analyse_analysis = Analyse.Collected.mk_analysis analyse_test objdump_d branchtables in
+  let print_analyse_instruction pc =
+    let pc = Elf.Address.to_sym pc in
+    let index = analyse_analysis.index_of_address pc in
+    let instr = analyse_analysis.instructions.(index) in
+    Analyse.Pp.pp_instruction Analyse.Types.Html (*Ascii*) analyse_test analyse_analysis 0 index
+      instr
+  in
+  (* base "Entry state:\n%t" Pp.(topi State.pp start); *)
+  match func.sym with
+  | None -> fail "Function %s exists in DWARF data but do not have any code" name
+  | Some sym ->
+      let endpred = Block_lib.gen_endpred () in
+      let runner = Runner.of_dwarf dwarf in
+      let block = Block_lib.make ~runner ~start:sym.addr ~endpred in
+      base "Start running";
+      let tree = Block_lib.run ~every_instruction:true block start in
+      base "Ended running, start pretty printing";
+      (* This table will contain the state diff to print at each pc with a message *)
+      (* let instr_data : (Elf.Address.t, string * State.t * State.Reg.t list) Hashtbl.t =
+        Hashtbl.create 100
+      in
+      let get_footprint pc =
+        Runner.get_normal_opt runner pc |> Option.fold ~none:[] ~some:Trace.Instr.footprint
+      in *)
+      State.Tree.iter
+        (fun a st ->
+          match a with
+          | Block_lib.Start -> ()
+          | Block_lib.BranchAt pc -> 
+              let last_pc = st.last_pc in
+              if Elf.Address.(last_pc + 4 <> pc) then
+                Printf.printf "\nJUMP from %t:\n " Pp.(top Elf.Address.pp last_pc);
+              print_string (print_analyse_instruction pc);
+              print_endline "BRANCH!";
+          | Block_lib.NormalAt pc ->
+              let last_pc = st.last_pc in
+              if Elf.Address.(last_pc + 4 <> pc) then
+                Printf.printf "\nJUMP from %t:\n " Pp.(top Elf.Address.pp last_pc);
+              print_string (print_analyse_instruction pc);
+          | Block_lib.End _ -> ())
+        tree;
+  match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
+  | Error _ -> ()
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
+
+
+let elf =
+  let doc = "ELF file from which to pull the code" in
+  Arg.(required & pos 0 (some non_dir_file) None & info [] ~docv:"ELF_FILE" ~doc)
+
+let func =
+  let doc = "Symbol name of the function to run" in
+  Arg.(value & pos 1 string "main" & info [] ~docv:"FUNCTION" ~doc)
+
+let objdump_d =
+  let doc = "File containing result of objdump -d" in
+  Arg.(required & opt (some non_dir_file) None & info ["objdump-d"] ~docv:"OBJDUMP_FILE" ~doc)
+
+let branch_table =
+  let doc = "File containing branch table base addresses and sizes" in
+  Arg.(
+    (* required *)
+    value & opt (some non_dir_file) None & info ["branch-tables"] ~docv:"BRANCH_TABLES_FILE" ~doc)
+
+let term =
+  Term.(
+    CmdlinerHelper.func_options comopts run_prog
+    $ elf $ func $ objdump_d $ branch_table)
+
+let info =
+  let doc =
+    "Run main of relocatable file"
+  in
+  Cmd.(info "run-rel-prog" ~doc ~exits)
+
+let command = (term, info)
+        
\ No newline at end of file

From 8b30d350b9d940d568eaf518549f11ab45278cc1 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 1 Feb 2025 19:38:24 +0000
Subject: [PATCH 048/116] Run and print debug info

---
 src/dw/loc.ml      |  8 +++++++
 src/run/relProg.ml | 59 +++++++++++++++++++++++++++++++++++++++++-----
 src/utils/sym.ml   |  4 +++-
 3 files changed, 64 insertions(+), 7 deletions(-)

diff --git a/src/dw/loc.ml b/src/dw/loc.ml
index 5d03061a..3ead2a51 100644
--- a/src/dw/loc.ml
+++ b/src/dw/loc.ml
@@ -72,6 +72,7 @@ type t =
   | RegisterOffset of State.Reg.t * int  (** At register + offset address *)
   | StackFrame of int  (** On the stackFrame with offset *)
   | Global of Elf.SymTable.sym_offset  (** Global variable with an offset *)
+  | Const of Z.t
   | Dwarf of dwop list  (** Uninterpreted dwarf location *)
 
 (** The type of a location in linksem format *)
@@ -128,6 +129,9 @@ let of_linksem ?(amap = Arch.dwarf_reg_map ()) (elf : Elf.File.t) : linksem_t ->
         Dwarf ops
     )
   (* Other *)
+  | [{ op_semantics = OpSem_lit; op_argument_values = [arg]; _ }; { op_semantics = OpSem_stack_value; _ }] ->
+      let value = Sym.to_z @@ sym_of_oav arg in 
+      Const value
   | ops -> Dwarf ops
 
 (** Convert the location to a string. This is not reversible *)
@@ -136,6 +140,7 @@ let to_string = function
   | RegisterOffset (reg, off) -> Printf.sprintf "[%s+%x]" (State.Reg.to_string reg) off
   | StackFrame off -> Printf.sprintf "[frame+%x]" off
   | Global symoff -> Elf.SymTable.string_of_sym_offset symoff
+  | Const x -> Z.to_string x
   | Dwarf ops -> Dwarf.pp_operations ops
 
 (** Compare two location. Loc.t is not compatible with polymorphic compare *)
@@ -154,6 +159,9 @@ let compare l1 l2 =
       Pair.compare ~fst:Elf.Symbol.compare (sym1, off1) (sym2, off2)
   | (Global (_, _), _) -> -1
   | (_, Global (_, _)) -> 1
+  | (Const x, Const y) -> Z.compare x y
+  | (Const _, _) -> -1
+  | (_, Const _) -> 1
   | (Dwarf ops1, Dwarf ops2) -> compare ops1 ops2
 
 (** Pretty-print the location *)
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index f2a3f202..62c3f8da 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -5,6 +5,51 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
+let pp_eval_loc sz st (loc: Dw.Loc.t) : PPrint.document =
+  let value = match loc with
+  | Register reg -> Some (State.get_reg_exp st reg)
+  | RegisterOffset (reg, off) ->
+      let r = State.get_reg_exp st reg in
+      Some (State.read_noprov st ~addr:Exp.Typed.(r + bits_int ~size:Arch.address_size off) ~size:(Ast.Size.of_bytes sz))
+  | StackFrame _off -> 
+      None
+  | Global symoff -> 
+      let addr = Elf.SymTable.to_addr_offset symoff in
+      let addr = State.Exp.of_address ~size:Arch.address_size addr in
+      Some (State.read_noprov st ~addr ~size:(Ast.Size.of_bytes sz))
+  | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
+  | Dwarf _ops -> None in
+  Pp.optional State.Exp.pp value
+
+let printvars ~st ~(dwarf: Dw.t) pc =
+  let st = State.copy_if_locked st in
+  let pv vars =
+    Seq.iter (fun (v: Dw.Var.t) -> 
+      let sz = Ctype.sizeof v.ctype in
+      match List.find_map (fun ((lo,hi), loc) -> Option.(
+        let open Elf.Address in
+        let* hi = hi in
+        let* over = lo <= pc in
+        let* under = pc < hi in
+        if over && under then
+          Some loc
+        else
+          None
+      )) v.locs with
+      | None -> ()
+      | Some loc -> Printf.printf "%s = %t\n" v.name Pp.(top (pp_eval_loc sz st) loc);
+    )
+    vars
+  in
+  pv (Hashtbl.to_seq_values dwarf.vars);
+  Hashtbl.iter (fun _ (fn:Dw.Func.t) ->
+    let rec pscope (scope:Dw.Func.scope) =
+      pv (List.to_seq scope.vars);
+      List.iter pscope scope.scopes
+    in
+    pscope fn.func.scope
+  ) dwarf.funcs
+
 
 let run_prog elfname name objdump_d branchtables =
   match Analyse.Utils.read_file_lines "src/analyse/html-preamble-insts.html" with
@@ -56,20 +101,22 @@ let run_prog elfname name objdump_d branchtables =
       in *)
       State.Tree.iter
         (fun a st ->
-          match a with
+          let last_pc = st.last_pc in
+          (match a with
           | Block_lib.Start -> ()
           | Block_lib.BranchAt pc -> 
-              let last_pc = st.last_pc in
               if Elf.Address.(last_pc + 4 <> pc) then
-                Printf.printf "\nJUMP from %t:\n " Pp.(top Elf.Address.pp last_pc);
+                Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
+              printvars ~st ~dwarf pc;
               print_string (print_analyse_instruction pc);
               print_endline "BRANCH!";
           | Block_lib.NormalAt pc ->
-              let last_pc = st.last_pc in
               if Elf.Address.(last_pc + 4 <> pc) then
-                Printf.printf "\nJUMP from %t:\n " Pp.(top Elf.Address.pp last_pc);
+                Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
+              printvars ~st ~dwarf pc;
               print_string (print_analyse_instruction pc);
-          | Block_lib.End _ -> ())
+          | Block_lib.End _ -> ());
+        )
         tree;
   match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
   | Error _ -> ()
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
index 839f5c96..1510a8b3 100644
--- a/src/utils/sym.ml
+++ b/src/utils/sym.ml
@@ -2,7 +2,9 @@ type t = Z.t Dwarf.sym0
 
 let pp x = x |> Dwarf.pphex_sym |> Pp.string
 
-let to_int x = Z.to_int @@ Dwarf.sym_unwrap x "to_int"
+let to_z x = Dwarf.sym_unwrap x "to_z"
+
+let to_int x = Z.to_int @@ to_z x
 
 let of_int x = Dwarf.Absolute (Z.of_int x)
 let of_int64 x = Dwarf.Absolute (Z.of_int64 x)

From 7c5fd5f45174f97ebf2092bd3d25389216248828 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 1 Feb 2025 20:32:54 +0000
Subject: [PATCH 049/116] Fix ldst relocations

---
 src/elf/relocations.ml |  2 +-
 src/isla/cache.ml      | 11 +++++------
 src/isla/relocation.ml |  8 ++++----
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index 1a60a8bd..66cdc831 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -81,7 +81,7 @@ let pp_target = Pp.(function
 | AArch64 Abi_aarch64_symbolic_relocation.ADD -> !^"ADD"
 | AArch64 Abi_aarch64_symbolic_relocation.ADRP -> !^"ADRP"
 | AArch64 Abi_aarch64_symbolic_relocation.CALL -> !^"CALL"
-| AArch64 Abi_aarch64_symbolic_relocation.LDST -> !^"LDST")
+| AArch64 Abi_aarch64_symbolic_relocation.LDST b -> !^"LDST" ^^ int (1 lsl b))
 
 let pp_rel rel =
   let hi, lo = rel.mask in
diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index e5c95d72..17a71ce6 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -85,8 +85,8 @@ module Opcode (*: Cache.Key *) = struct
   | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320) -> 2
   | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP) -> 3
   | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD) -> 4
-  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST) -> 5
-  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 6
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 5
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST b) -> 6 + b
 
   let reloc_of_id: int -> Relocation.t option = function
   | 0 -> None
@@ -94,9 +94,8 @@ module Opcode (*: Cache.Key *) = struct
   | 2 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320)
   | 3 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP)
   | 4 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD)
-  | 5 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST)
-  | 6 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL)
-  | _ -> Raise.fail "invalid reloc id"
+  | 5 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL)
+  | x -> Some (Elf.Relocations.AArch64 (Abi_aarch64_symbolic_relocation.LDST (x-6)))
 
   let equal a b =
     match (a, b) with
@@ -105,7 +104,7 @@ module Opcode (*: Cache.Key *) = struct
     | _ -> false
 
   let small_enough bs rel_id =
-    BytesSeq.length bs < BytesSeq.int_bytes && rel_id < 8
+    BytesSeq.length bs < (BytesSeq.int_bytes-1) && rel_id < (8*256)
 
   let hash = function
     | None -> 0
diff --git a/src/isla/relocation.ml b/src/isla/relocation.ml
index 3e3004ad..d8e17a5a 100644
--- a/src/isla/relocation.ml
+++ b/src/isla/relocation.ml
@@ -25,9 +25,9 @@ let pp_opcode_with_segments (b, r) =
             BitVec.pp_smt (BitVec.extract 22 31 bits)  
             ^^ !^" x0:12 " ^^
             BitVec.pp_smt (BitVec.extract 0 9 bits)
-        | Abi_aarch64_symbolic_relocation.LDST -> (* TODO different width loads, alignment *) 
-            BitVec.pp_smt (BitVec.extract 20 31 bits)  
-            ^^ !^" x0:10 " ^^
+        | Abi_aarch64_symbolic_relocation.LDST b -> (* TODO different width loads, alignment *) 
+            BitVec.pp_smt (BitVec.extract (22-b) 31 bits)  
+            ^^ !^" x0:" ^^ int (12-b) ^^ !^" " ^^
             BitVec.pp_smt (BitVec.extract 0 9 bits)
         | Abi_aarch64_symbolic_relocation.CALL -> 
             BitVec.pp_smt (BitVec.extract 26 31 bits)  
@@ -40,5 +40,5 @@ let segments_of_reloc: t -> segment list = function
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320 -> fatal "invalid relocation for instructions (Data32)"
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP -> ["x0", (0, 1); "x1", (2, 20)] (* or absolute? ["x0", (12, 13); "x1", (14, 32)] *)
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD -> ["x0", (0, 11)]
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST -> ["x0", (0, 9)] (* TODO depends on load size *) (* or absolute? ["x0", (2, 11)] *)
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST b -> ["x0", (0, 11-b)] (* TODO depends on load size *) (* or absolute? ["x0", (2, 11)] *)
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL -> ["x0", (0, 25)] (* or absolute? ["x0", (2, 27)] *)
\ No newline at end of file

From 84798b3f458e6f8e72f045a7db84dce05e8584f6 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 5 Feb 2025 16:07:48 +0000
Subject: [PATCH 050/116] Fix rngmap croping

---
 src/utils/rngMap.ml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/utils/rngMap.ml b/src/utils/rngMap.ml
index 1e81ad21..42f872cb 100644
--- a/src/utils/rngMap.ml
+++ b/src/utils/rngMap.ml
@@ -303,14 +303,20 @@ module Make (Obj : LenObject) : S with type obj = Obj.t = struct
   let clear_crop t ~pos ~len ~crop =
     assert (len >= 0);
     (* Crop an possible object starting before the start but ending after the start. *)
+    let endp = pos + len in
     let t =
       match prev t (pos - 1) with
       | Some (addr, obj) when addr + Obj.len obj > pos ->
+        let objend = addr + Obj.len obj in 
+        let t = if endp < objend then
+            IMap.add (pos + len) (crop ~pos:(endp - addr) ~len:(objend - endp) obj) t
+          else
+            t
+          in
           IMap.update addr (Option.map (crop ~pos:0 ~len:(pos - addr))) t
       | _ -> t
     in
     let seq = IMap.to_seq_from pos t in
-    let endp = pos + len in
     (* Remove all objects of the sequence from t until endp *)
     let rec remove_until t seq endp =
       match seq () with

From 688d53968d96d30ea805fd7572ab40b8ca2b5eab Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 5 Feb 2025 16:22:25 +0000
Subject: [PATCH 051/116] Fix symbolic bytes sub

---
 src/state/symbolicBytes.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/state/symbolicBytes.ml b/src/state/symbolicBytes.ml
index e9bf6836..2693b0b3 100644
--- a/src/state/symbolicBytes.ml
+++ b/src/state/symbolicBytes.ml
@@ -148,7 +148,7 @@ module Make (Var : Exp.Var) : S with type var = Var.t = struct
                        |<off_len>|
              *)
           let next = pos + off_len in
-          let* rest = sub_list ~pos:next ~len:(len - next) sb in
+          let* rest = sub_list ~pos:next ~len:(len - off_len) sb in
           let nexp = Typed.extract ~last:((8 * elen) - 1) ~first:(8 * off) e in
           Some (nexp :: rest)
         else

From a9b1c224e6c1224be6bacc4e673d7677a1bbf805 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 5 Feb 2025 16:28:18 +0000
Subject: [PATCH 052/116] Eval debug variable expressions

---
 src/run/relProg.ml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 62c3f8da..e0923831 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -19,7 +19,11 @@ let pp_eval_loc sz st (loc: Dw.Loc.t) : PPrint.document =
       Some (State.read_noprov st ~addr ~size:(Ast.Size.of_bytes sz))
   | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
   | Dwarf _ops -> None in
-  Pp.optional State.Exp.pp value
+  Pp.optional (fun value ->
+    match Exp.ConcreteEval.eval_if_concrete value with
+    | Some(value) -> Exp.Value.pp value
+    | None -> State.Exp.pp value
+  ) value
 
 let printvars ~st ~(dwarf: Dw.t) pc =
   let st = State.copy_if_locked st in

From 02cf6019379bb7ca1cf3394c875610488ce86ad5 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 5 Feb 2025 17:32:13 +0000
Subject: [PATCH 053/116] Nicer print (needs testing)

---
 src/run/relProg.ml | 44 ++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 40 insertions(+), 4 deletions(-)

diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index e0923831..16a277b1 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -5,7 +5,42 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-let pp_eval_loc sz st (loc: Dw.Loc.t) : PPrint.document =
+let rec pp_array pp sz dims value =
+  match dims with
+  | [] -> pp value
+  | None::_ -> pp value
+  | Some d :: dims ->
+      let sz = sz / d in
+      Seq.iota d
+      |> Seq.map (fun x -> Exp.Typed.extract ~first:(8*x*sz) ~last:(8*(x+1)*sz-1) value)
+      |> List.of_seq
+      |> Pp.list (pp_array pp sz dims) 
+
+let pp_typed ~(tenv: Ctype.env) ~(ctype: Ctype.t) ~pp (value: State.Exp.t) =
+  match ctype.unqualified with
+  | Machine _ -> pp value
+  | Cint _ -> pp value
+  | Cbool -> pp value
+  | Ptr _ -> pp value
+  | Struct { id; _ } ->
+      let s = IdMap.geti tenv.structs id in
+      Pp.(
+        Ctype.FieldMap.to_seq s.layout
+        |> Seq.map (fun (offset, (field:Ctype.field)) -> (
+          opt string field.fname,
+          pp (Exp.Typed.extract ~first:(8*offset) ~last:(8*(offset + field.size)-1) value)
+        ))
+        |> List.of_seq
+        |> mapping s.name
+      )
+  | Array { dims; _ } ->
+      let sz = Ctype.sizeof ctype in
+      pp_array pp sz dims value
+  | Enum _ -> pp value
+  | FuncPtr -> pp value
+  | Missing -> pp value
+
+let pp_eval_loc sz st ~(tenv: Ctype.env) ~(ctype: Ctype.t) (loc: Dw.Loc.t) : PPrint.document =
   let value = match loc with
   | Register reg -> Some (State.get_reg_exp st reg)
   | RegisterOffset (reg, off) ->
@@ -19,11 +54,12 @@ let pp_eval_loc sz st (loc: Dw.Loc.t) : PPrint.document =
       Some (State.read_noprov st ~addr ~size:(Ast.Size.of_bytes sz))
   | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
   | Dwarf _ops -> None in
-  Pp.optional (fun value ->
+  let pp = fun value ->
     match Exp.ConcreteEval.eval_if_concrete value with
     | Some(value) -> Exp.Value.pp value
     | None -> State.Exp.pp value
-  ) value
+  in
+  Pp.optional (pp_typed ~tenv ~ctype ~pp) value
 
 let printvars ~st ~(dwarf: Dw.t) pc =
   let st = State.copy_if_locked st in
@@ -41,7 +77,7 @@ let printvars ~st ~(dwarf: Dw.t) pc =
           None
       )) v.locs with
       | None -> ()
-      | Some loc -> Printf.printf "%s = %t\n" v.name Pp.(top (pp_eval_loc sz st) loc);
+      | Some loc -> Printf.printf "%s = %t\n" v.name Pp.(top (pp_eval_loc sz st ~ctype:v.ctype ~tenv:dwarf.tenv) loc);
     )
     vars
   in

From 81d0deca0bf32fd0aff2d8ee3f6c839701aa637a Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 15 Feb 2025 16:49:48 +0000
Subject: [PATCH 054/116] nicer print

---
 src/run/relProg.ml | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 16a277b1..6b140beb 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -40,18 +40,28 @@ let pp_typed ~(tenv: Ctype.env) ~(ctype: Ctype.t) ~pp (value: State.Exp.t) =
   | FuncPtr -> pp value
   | Missing -> pp value
 
+let read_big st addr sz =
+  Seq.iota_step_up ~step:16 ~endi:sz
+  |> Seq.map (fun off ->
+    let addr = Exp.Typed.(addr + bits_int ~size:Arch.address_size off) in
+    let len = min 16 (sz - off) in
+    State.read_noprov st ~addr ~size:(Ast.Size.of_bytes len)
+  )
+  |> List.of_seq
+  |> Exp.Typed.concat
+
 let pp_eval_loc sz st ~(tenv: Ctype.env) ~(ctype: Ctype.t) (loc: Dw.Loc.t) : PPrint.document =
   let value = match loc with
   | Register reg -> Some (State.get_reg_exp st reg)
   | RegisterOffset (reg, off) ->
       let r = State.get_reg_exp st reg in
-      Some (State.read_noprov st ~addr:Exp.Typed.(r + bits_int ~size:Arch.address_size off) ~size:(Ast.Size.of_bytes sz))
+      Some (read_big st Exp.Typed.(r + bits_int ~size:Arch.address_size off) sz)
   | StackFrame _off -> 
       None
   | Global symoff -> 
       let addr = Elf.SymTable.to_addr_offset symoff in
       let addr = State.Exp.of_address ~size:Arch.address_size addr in
-      Some (State.read_noprov st ~addr ~size:(Ast.Size.of_bytes sz))
+      Some (read_big st addr sz)
   | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
   | Dwarf _ops -> None in
   let pp = fun value ->
@@ -62,6 +72,8 @@ let pp_eval_loc sz st ~(tenv: Ctype.env) ~(ctype: Ctype.t) (loc: Dw.Loc.t) : PPr
   Pp.optional (pp_typed ~tenv ~ctype ~pp) value
 
 let printvars ~st ~(dwarf: Dw.t) pc =
+  let out = ref "" in
+
   let st = State.copy_if_locked st in
   let pv vars =
     Seq.iter (fun (v: Dw.Var.t) -> 
@@ -77,7 +89,7 @@ let printvars ~st ~(dwarf: Dw.t) pc =
           None
       )) v.locs with
       | None -> ()
-      | Some loc -> Printf.printf "%s = %t\n" v.name Pp.(top (pp_eval_loc sz st ~ctype:v.ctype ~tenv:dwarf.tenv) loc);
+      | Some loc -> out := !out ^ Printf.sprintf "%s = %t\n" v.name Pp.(tos (pp_eval_loc sz st ~ctype:v.ctype ~tenv:dwarf.tenv) loc);
     )
     vars
   in
@@ -88,7 +100,8 @@ let printvars ~st ~(dwarf: Dw.t) pc =
       List.iter pscope scope.scopes
     in
     pscope fn.func.scope
-  ) dwarf.funcs
+  ) dwarf.funcs;
+  !out
 
 
 let run_prog elfname name objdump_d branchtables =
@@ -147,13 +160,13 @@ let run_prog elfname name objdump_d branchtables =
           | Block_lib.BranchAt pc -> 
               if Elf.Address.(last_pc + 4 <> pc) then
                 Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
-              printvars ~st ~dwarf pc;
+              print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
               print_string (print_analyse_instruction pc);
               print_endline "BRANCH!";
           | Block_lib.NormalAt pc ->
               if Elf.Address.(last_pc + 4 <> pc) then
                 Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
-              printvars ~st ~dwarf pc;
+              print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
               print_string (print_analyse_instruction pc);
           | Block_lib.End _ -> ());
         )

From 83f1d45c040870e7bc0f59a63dbe4b8fa6d291ef Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 15 Feb 2025 23:45:16 +0000
Subject: [PATCH 055/116] Take state init function as arg in Run.Func

---
 src/run/func.ml    | 10 +++++-----
 src/run/func.mli   |  1 +
 src/state/base.ml  | 11 +++++++++++
 src/state/base.mli |  3 +++
 4 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/run/func.ml b/src/run/func.ml
index 91167c8b..44ab9e46 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -52,7 +52,7 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-let no_run_prep ~elf:elfname ~name ~entry =
+let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic) () =
   base "Running %s in %s" name elfname;
   let dwarf = Dw.of_file elfname in
   let elf = dwarf.elf in
@@ -66,13 +66,13 @@ let no_run_prep ~elf:elfname ~name ~entry =
   let abi = Arch.get_abi api in
   Trace.Cache.start @@ Arch.get_isla_config ();
   base "Computing entry state";
-  let start = Init.state () |> State.copy ~elf |> State.init_sections ~addr_size:Arch.address_size |> abi.init in
+  let start = Init.state () |> State.copy ~elf |> init |> abi.init in
   if entry then base "Entry state:\n%t" (Pp.topi State.pp start);
   (dwarf, elf, func, start)
 
 let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(breakpoints = [])
-    ?loop ?tree_to_file () =
-  let (dwarf, elf, func, start) = no_run_prep ~elf:elfname ~name ~entry in
+    ?loop ?tree_to_file ?init () =
+  let (dwarf, elf, func, start) = no_run_prep ~elf:elfname ~name ~entry ?init () in
   match func.sym with
   | None -> fail "Function %s exists in DWARF data but does not have any code" name
   | Some sym ->
@@ -104,7 +104,7 @@ let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(br
       tree
 
 let cmd_func elfname name dump no_run entry len breakpoints loop tree_to_file =
-  if no_run then ignore @@ no_run_prep ~elf:elfname ~name ~entry
+  if no_run then ignore @@ no_run_prep ~elf:elfname ~name ~entry ()
   else
     ignore
     @@ get_state_tree ~elf:elfname ~name ~dump ~entry ?len ~breakpoints ?loop ?tree_to_file ()
diff --git a/src/run/func.mli b/src/run/func.mli
index 7f72d3f5..548f1f07 100644
--- a/src/run/func.mli
+++ b/src/run/func.mli
@@ -7,6 +7,7 @@ val get_state_tree :
   ?breakpoints:string list ->
   ?loop:int ->
   ?tree_to_file:string ->
+  ?init:(State.t -> State.t) ->
   unit ->
   Block_lib.label State.Tree.t
 
diff --git a/src/state/base.ml b/src/state/base.ml
index 96e35997..b214b4c3 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -546,6 +546,17 @@ let init_sections ~addr_size state =
   ) in
   state
 
+let init_sections_symbolic state =
+  let state = copy_if_locked state in
+  let _ = Option.(
+    let+ elf = state.elf in
+    Elf.SymTable.iter elf.symbols @@ fun sym ->
+      if sym.typ = Elf.Symbol.OBJECT then
+        Hashtbl.replace state.mem.sections sym.addr.section Main
+  ) in
+  state
+
+
 let map_mut_exp (f : exp -> exp) s : unit =
   assert (not @@ is_locked s);
   Reg.Map.map_mut_current (Tval.map_exp f) s.regs;
diff --git a/src/state/base.mli b/src/state/base.mli
index 665b61a9..73f123db 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -404,6 +404,9 @@ val copy_if_locked : ?elf:Elf.File.t -> t -> t
 
 val init_sections : addr_size:int -> t -> t
 
+(** Assigns all sections with global objects to Main fragment *)
+val init_sections_symbolic : t -> t
+
 
 (** {1 State convenience manipulation } *)
 

From 7ad05907d0166c88f136b9700493e05e70378d0d Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 15 Feb 2025 23:49:57 +0000
Subject: [PATCH 056/116] Make Sums.split sound

We can guarantee that
(a+b)[first:last] = a[first:last]+b[first:last]
only when first=0
---
 src/exp/sums.ml | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/src/exp/sums.ml b/src/exp/sums.ml
index 6d843f5d..287f4936 100644
--- a/src/exp/sums.ml
+++ b/src/exp/sums.ml
@@ -52,7 +52,7 @@ let rec split =
   let open Ast in
   function
   | Manyop (Bvmanyarith Bvadd, l, _) -> List.concat_map split l
-  | Unop (Extract (last, first), e, _) ->
+  | Unop (Extract (last, (0 as first)), e, _) ->
       let l = split e in
       List.map (Typed.extract ~first ~last) l
   | Unop (Bvneg, e, _) ->
@@ -63,20 +63,6 @@ let rec split =
       let l' = split e' in
       let rl' = List.rev_map Typed.neg l' in
       List.rev_append rl' l
-  | Manyop (Concat, l, _) ->
-      let all_splits = List.map split l in
-      let defaults = List.map (fun e ->
-        let size = e |> Typed.get_type |> Typed.expect_bv in
-        Typed.bits_int ~size 0
-      ) l in
-      let terms = List.transpose ~defaults all_splits in
-      List.map Typed.concat terms
-  | Unop (ZeroExtend m, e, _) ->
-      let l = split e in
-      List.map (Typed.unop (ZeroExtend m)) l
-  | Unop (SignExtend s, e, _) ->
-      let l = split e in
-      List.map (Typed.unop (SignExtend s)) l
   | e -> [e]
 
 let merge ~size l = if l = [] then Typed.zero ~size else Typed.sum l

From 94304463890893d7011d84053e2af613a45f17e1 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 25 Feb 2025 10:27:00 +0000
Subject: [PATCH 057/116] Context simplifier for relocation

TODO: move all simplification here instead of read_noprov
---
 src/relsim/base.ml   | 115 +++++++++++++++++++++++++++++++++++++++++++
 src/state/base.ml    |   1 +
 src/trace/context.ml |  19 +++++--
 src/trace/run.ml     |  13 +++--
 src/z3/z3.ml         |   4 --
 5 files changed, 138 insertions(+), 14 deletions(-)
 create mode 100644 src/relsim/base.ml

diff --git a/src/relsim/base.ml b/src/relsim/base.ml
new file mode 100644
index 00000000..43df0a71
--- /dev/null
+++ b/src/relsim/base.ml
@@ -0,0 +1,115 @@
+(* open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
+module Sums = Exp.Sums
+module Typed = Exp.Typed
+
+module Var = struct
+    (** The type of variables *)
+  type t = Left of State.var | Right of State.var
+
+  let equal a b = match (a,b) with
+  | Left a, Left b -> State.Var.equal a b
+  | Right a, Right b -> State.Var.equal a b
+  | _ -> false
+
+  let pp = function
+  | Left v -> Pp.(!^"L:" ^^ State.Var.pp v)
+  | Right v -> Pp.(!^"R:" ^^ State.Var.pp v)
+
+  (** Get the type of the variable *)
+  let ty = function Left v | Right v -> State.Var.ty v
+
+  let hash = Hashtbl.hash
+
+  let of_string = State.Var.of_string (*TODO*)
+end
+
+module Exp = struct
+  include Exp.Make (Var)
+
+  let left : State.Exp.t -> t = Ast.Manip.exp_map_var (fun v -> Var.Left v)
+
+  let right : State.Exp.t -> t = Ast.Manip.exp_map_var (fun v -> Var.Right v)
+end
+
+type sem_type =
+  | Value of int
+  | Ptr of sem_type
+
+type mem_rel = (State.Exp.t * State.Exp.t * sem_type) list
+
+let rec sem_type_of_ctype Ctype.{unqualified; _} =
+  match unqualified with
+  | Machine b -> Value b
+  | Cint { size; _ } -> Value size
+  | Cbool -> Value 1
+  | Ptr { fragment=Ctype.DynArray t; _ } -> Ptr (sem_type_of_ctype t)
+  | _ -> Raise.todo()
+
+let mem_rel_of_dwarf (dw: (Dw.Var.t * Dw.Var.t) list) : mem_rel =
+  List.map (fun ((v1: Dw.Var.t), (v2: Dw.Var.t)) ->
+    let addr1 = match v1.locs with
+    | [_, Global a] -> 
+      a |> Elf.SymTable.to_addr_offset 
+        |> State.Exp.of_address ~size:Arch.address_size
+        (* |> Ast.Manip.exp_map_var (fun x -> Var.Left x) *)
+    | _ -> Raise.todo()
+    in
+    let addr2 = match v2.locs with
+    | [_, Global a] -> 
+      a |> Elf.SymTable.to_addr_offset 
+        |> State.Exp.of_address ~size:Arch.address_size
+        (* |> Ast.Manip.exp_map_var (fun x -> Var.Right x) *)
+    | _ -> Raise.todo()
+    in
+    let stp = sem_type_of_ctype v1.ctype in
+    (addr1, addr2, stp)
+  ) dw
+
+type rel = mem_rel * Exp.t list
+
+type event = State.Mem.Fragment.Event.t
+type block = State.Mem.Fragment.Block.t
+
+let type_at (mem_rel:mem_rel) (block1:block) (block2:block) =
+  List.find_map (fun (e1,e2,t) ->
+    let (sym1, off1) = Sums.split_concrete e1 in
+    let (sym2, off2) = Sums.split_concrete e2 in
+    if (BitVec.to_int off1 == block1.offset && BitVec.to_int off2 == block2.offset
+        && Option.equal State.Exp.equal sym1 block1.base
+        && Option.equal State.Exp.equal sym2 block2.base)
+    then
+      Some t
+    else
+      None
+  ) mem_rel
+
+module Z3sim = Z3.Make (Var)
+
+let update_rel ((mem, asserts):rel) (e1: event) (e2: event) : rel =
+  (* TODO check sizes *)
+  match e1, e2 with
+  | (Read (block1, v1), Read (block2, v2)) -> (
+      match type_at mem block1 block2 with
+      | Some (Value _) -> mem, Typed.(Exp.of_var (Left v1) = Exp.of_var (Right v2))::asserts
+      | Some (Ptr t) -> (State.Exp.of_var v1, State.Exp.of_var v2, t)::mem, asserts
+      | None -> mem, asserts
+    )
+  | (Write (block1, e1), Write (block2, e2)) -> (
+      (match type_at mem block1 block2 with
+      | Some (Value _) -> Z3
+      | Some (Ptr t) -> Raise.todo() (* Check (e1, e2, t) in mem *)
+      | None -> Raise.fail "simrel failed");
+      mem, asserts
+    )
+  | _ -> Raise.fail "simrel failed"
+
+
+let verify (st1:State.t) (st2:State.t) (dw:(Dw.Var.t * Dw.Var.t) list) =
+  let mem_rel = mem_rel_of_dwarf dw in
+  Raise.todo()
+
+  
+ *)
diff --git a/src/state/base.ml b/src/state/base.ml
index b214b4c3..eebb0ace 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -645,6 +645,7 @@ let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
   
 
 let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+  debug "Addr: %t" Pp.(top Exp.pp addr);
   let elf_addr = eval_address s addr in
   debug "Address: %t" Pp.(top (optional Elf.Address.pp) elf_addr);
   match elf_addr with
diff --git a/src/trace/context.ml b/src/trace/context.ml
index 66a045ee..f233abe9 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -60,6 +60,7 @@ type t = {
   mem_reads : State.tval HashVector.t;  (** Stores the result of memory reads *)
   state : State.t;
   segments : State.exp SMap.t;
+  asserts: State.exp list;
   dwarf : Dw.t option;  (** Optionally DWARF information. If present, typing is enabled *)
 }
 
@@ -68,19 +69,20 @@ let make_context ?dwarf ?relocation state =
   let reg_writes = Vec.empty () in
   let mem_reads = HashVector.empty () in
 
-  let segments = relocation
+  let segments, asserts = relocation
     |> Option.map (fun relocation ->
       let State.Relocation.{value;asserts;target} = State.Relocation.of_elf relocation in
       List.iter (State.push_relocation_assert state) asserts;
 
-      target
+      (target
       |> Isla.Relocation.segments_of_reloc
       |> SMap.of_list
-      |> SMap.map (fun (first, last) -> Exp.Typed.extract ~first ~last value)
+      |> SMap.map (fun (first, last) -> Exp.Typed.extract ~first ~last value),
+      asserts)
       )
-    |> Option.value ~default:SMap.empty
+    |> Option.value ~default:(SMap.empty, [])
   in
-  { state; reg_writes; mem_reads; dwarf; segments }
+  { state; reg_writes; mem_reads; dwarf; segments; asserts }
 
 (** Expand a Trace variable to a State expression, using the context *)
 let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
@@ -93,3 +95,10 @@ let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
 
 (** Tell if typing should enabled with this context *)
 let typing_enabled ~(ctxt : t) = ctxt.dwarf <> None
+
+module Z3St = State.Simplify.Z3St
+
+let simplify ~(ctxt : t) (exp : State.exp) : State.exp =
+  exp
+  |> Z3St.simplify_subterms_full ~hyps:ctxt.asserts
+  |> Z3St.simplify_full
\ No newline at end of file
diff --git a/src/trace/run.ml b/src/trace/run.ml
index 45c9252d..b0250aae 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -64,12 +64,15 @@ type ctxt = Ctxt.t
 let expand ~(ctxt : ctxt) (exp : Base.exp) : State.exp =
   Ast.Manip.exp_var_subst (Ctxt.expand_var ~ctxt) exp
 
+let expand_simplify ~(ctxt : ctxt) (exp : Base.exp) : State.exp =
+  exp |> expand ~ctxt |> Context.simplify ~ctxt
+
 (** Expand a Trace expression to a typed State expression, using the context.
 
     If the context enables typing, the expression will actually be typed,
     otherwise the type will be [None] *)
 let expand_tval ~(ctxt : ctxt) (exp : Base.exp) : State.tval =
-  let sexp = expand ~ctxt exp in
+  let sexp = expand_simplify ~ctxt exp in
   if Ctxt.typing_enabled ~ctxt then
     let ctyp = Typer.expr ~ctxt exp in
     { ctyp; exp = sexp }
@@ -84,7 +87,7 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
   match event with
   | WriteReg { reg; value } -> Vec.add_one ctxt.reg_writes (reg, expand_tval ~ctxt value)
   | ReadMem { addr; value; size } ->
-      let naddr = expand ~ctxt addr in
+      let naddr = expand_simplify ~ctxt addr in
       debug "naddr: %t" (Pp.top State.Exp.pp naddr);
       let ptrtype = Typer.expr ~ctxt addr in
       debug "ptrtype: %t" Pp.(top (optional Ctype.pp) ptrtype);
@@ -97,7 +100,7 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
       in
       HashVector.set ctxt.mem_reads value tval
   | WriteMem { addr; value; size } -> (
-      let naddr = expand ~ctxt addr in
+      let naddr = expand_simplify ~ctxt addr in
       debug "naddr: %t" (Pp.top State.Exp.pp naddr);
       let ptrtype = Typer.expr ~ctxt addr in
       debug "ptrtype: %t" Pp.(top (optional Ctype.pp) ptrtype);
@@ -108,10 +111,10 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
           let value = expand_tval ~ctxt value in
           Typer.write ~dwarf ctxt.state ?ptrtype ~addr:naddr ~size value
       | None ->
-          let value = expand ~ctxt value in
+          let value = expand_simplify ~ctxt value in
           State.write_noprov ctxt.state ~addr:naddr ~size value
     )
-  | Assert exp -> State.push_assert ctxt.state (expand ~ctxt exp)
+  | Assert exp -> State.push_assert ctxt.state (expand_simplify ~ctxt exp)
 
 (** Run a trace on the provided state by mutation. Enable typing if [dwarf] is provided *)
 let trace_mut ?dwarf ?relocation (state : State.t) (events : Base.t) : unit =
diff --git a/src/z3/z3.ml b/src/z3/z3.ml
index 73733720..52c31a95 100644
--- a/src/z3/z3.ml
+++ b/src/z3/z3.ml
@@ -527,12 +527,8 @@ module Make (Var : Var) : S with type var = Var.t = struct
   let rec simplify_subterms serv (e : Exp.t) : Exp.t =
     e |> Ast.Manip.all_subterms
     |> List.find_opt (fun t ->
-      let et = Typed.get_type e in
-      let tt = Typed.get_type t in
-      Printf.printf "Types: %t, %t\n" Pp.(top Ast.pp_ty (Ast.Manip.ty_allow_mem et)) Pp.(top Ast.pp_ty (Ast.Manip.ty_allow_mem tt));
       Typed.get_type e = Typed.get_type t &&
       let result = check serv Typed.(e = t) in
-      Printf.printf "%t\n" Pp.(top (optional bool) result);
       result = Some true
     )
     |> Option.map (simplify_subterms serv)

From 27b4dafaa7fa8399491c039e362e9005d1dee5b5 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 18 Mar 2025 21:16:13 +0000
Subject: [PATCH 058/116] Fix caching

---
 src/isla/cache.ml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index 17a71ce6..be6f64e8 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -115,7 +115,7 @@ module Opcode (*: Cache.Key *) = struct
         if small_enough bs rel_id then begin
           assert (not @@ IntBits.get i IntBits.back);
           let res = IntBits.blit l 0 i (IntBits.back - 3) 3 in
-          let res = IntBits.blit rel_id 0 res (IntBits.back - 6) 3 in
+          let res = IntBits.blit rel_id 0 res (IntBits.back - 14) 11 in
           res
         end
         else IntBits.set i IntBits.back
@@ -133,8 +133,8 @@ module Opcode (*: Cache.Key *) = struct
     else if IntBits.get hash IntBits.back then
       Raise.todo()
     else
-      let data = IntBits.sub hash 0 (IntBits.back - 6) in
-      let reloc_id = IntBits.sub hash (IntBits.back - 6) 3 in
+      let data = IntBits.sub hash 0 (IntBits.back - 14) in
+      let reloc_id = IntBits.sub hash (IntBits.back - 14) 11 in
       let size = IntBits.sub hash (IntBits.back - 3) 3 in
       let b = Bytes.create size in
       Bits.unsafe_blit_of_int data 0 b 0 (size * 8);

From 65eb0ae18e2e0c4b1d2131fa32137ed217213469 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 18 Mar 2025 21:47:59 +0000
Subject: [PATCH 059/116] Refactor: use get_state_tree in run_prog

---
 src/run/func.ml    |  4 +--
 src/run/func.mli   |  1 +
 src/run/relProg.ml | 77 +++++++++++++++++-----------------------------
 3 files changed, 32 insertions(+), 50 deletions(-)

diff --git a/src/run/func.ml b/src/run/func.ml
index 44ab9e46..2c5968c4 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -71,7 +71,7 @@ let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic)
   (dwarf, elf, func, start)
 
 let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(breakpoints = [])
-    ?loop ?tree_to_file ?init () =
+    ?loop ?tree_to_file ?init ?every_instruction () =
   let (dwarf, elf, func, start) = no_run_prep ~elf:elfname ~name ~entry ?init () in
   match func.sym with
   | None -> fail "Function %s exists in DWARF data but does not have any code" name
@@ -96,7 +96,7 @@ let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(br
         base "Instructions:\n%t\n" (Pp.topi Runner.pp_instr runner)
       end;
       base "Start running";
-      let tree = Block_lib.run block start in
+      let tree = Block_lib.run block start ?every_instruction in
       tree_to_file
       |> Option.iter (fun x ->
              Files.write_string x @@ Pp.tos (State.Tree.pp_all Block_lib.pp_label) tree ());
diff --git a/src/run/func.mli b/src/run/func.mli
index 548f1f07..eac27b23 100644
--- a/src/run/func.mli
+++ b/src/run/func.mli
@@ -8,6 +8,7 @@ val get_state_tree :
   ?loop:int ->
   ?tree_to_file:string ->
   ?init:(State.t -> State.t) ->
+  ?every_instruction:bool ->
   unit ->
   Block_lib.label State.Tree.t
 
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 6b140beb..e375db07 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -112,18 +112,6 @@ let run_prog elfname name objdump_d branchtables =
   base "Running with rd %s in %s" name elfname;
   base "Loading %s" elfname;
   let dwarf = Dw.of_file elfname in
-  let elf = dwarf.elf in
-  let func =
-    Dw.get_func_opt ~name dwarf
-    |> Option.value_fun ~default:(fun () -> fail "Function %s wasn't found in %s" name elfname)
-  in
-  let api = Dw.Func.get_api func in
-  base "API %t" (Pp.top Arch.pp_api api);
-  base "Loading ABI";
-  let abi = Arch.get_abi api in
-  Trace.Cache.start @@ Arch.get_isla_config ();
-  base "Computing entry state";
-  let start = Init.state () |> State.copy ~elf |> State.init_sections ~addr_size:Arch.address_size |> abi.init in
   base "Loading %s for Analyse" elfname;
   let analyse_test = Analyse.Elf.parse_elf_file elfname in
   base "Analysing %s for Analyse" elfname;
@@ -135,42 +123,35 @@ let run_prog elfname name objdump_d branchtables =
     Analyse.Pp.pp_instruction Analyse.Types.Html (*Ascii*) analyse_test analyse_analysis 0 index
       instr
   in
-  (* base "Entry state:\n%t" Pp.(topi State.pp start); *)
-  match func.sym with
-  | None -> fail "Function %s exists in DWARF data but do not have any code" name
-  | Some sym ->
-      let endpred = Block_lib.gen_endpred () in
-      let runner = Runner.of_dwarf dwarf in
-      let block = Block_lib.make ~runner ~start:sym.addr ~endpred in
-      base "Start running";
-      let tree = Block_lib.run ~every_instruction:true block start in
-      base "Ended running, start pretty printing";
-      (* This table will contain the state diff to print at each pc with a message *)
-      (* let instr_data : (Elf.Address.t, string * State.t * State.Reg.t list) Hashtbl.t =
-        Hashtbl.create 100
-      in
-      let get_footprint pc =
-        Runner.get_normal_opt runner pc |> Option.fold ~none:[] ~some:Trace.Instr.footprint
-      in *)
-      State.Tree.iter
-        (fun a st ->
-          let last_pc = st.last_pc in
-          (match a with
-          | Block_lib.Start -> ()
-          | Block_lib.BranchAt pc -> 
-              if Elf.Address.(last_pc + 4 <> pc) then
-                Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
-              print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
-              print_string (print_analyse_instruction pc);
-              print_endline "BRANCH!";
-          | Block_lib.NormalAt pc ->
-              if Elf.Address.(last_pc + 4 <> pc) then
-                Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
-              print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
-              print_string (print_analyse_instruction pc);
-          | Block_lib.End _ -> ());
-        )
-        tree;
+  base "Start running";
+  let tree = Func.get_state_tree ~elf:elfname ~name ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:true () in
+  base "Ended running, start pretty printing";
+  (* This table will contain the state diff to print at each pc with a message *)
+  (* let instr_data : (Elf.Address.t, string * State.t * State.Reg.t list) Hashtbl.t =
+    Hashtbl.create 100
+  in
+  let get_footprint pc =
+    Runner.get_normal_opt runner pc |> Option.fold ~none:[] ~some:Trace.Instr.footprint
+  in *)
+  State.Tree.iter
+    (fun a st ->
+      let last_pc = st.last_pc in
+      (match a with
+      | Block_lib.Start -> ()
+      | Block_lib.BranchAt pc -> 
+          if Elf.Address.(last_pc + 4 <> pc) then
+            Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
+          print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
+          print_string (print_analyse_instruction pc);
+          print_endline "BRANCH!";
+      | Block_lib.NormalAt pc ->
+          if Elf.Address.(last_pc + 4 <> pc) then
+            Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
+          print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
+          print_string (print_analyse_instruction pc);
+      | Block_lib.End _ -> ());
+    )
+    tree;
   match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
   | Error _ -> ()
   | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines

From f025a7c84ab25917c9056892e7b9141b4432d99b Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 9 Apr 2025 09:55:00 +0100
Subject: [PATCH 060/116] Update for changes in linksem

---
 src/analyse/ControlFlow.ml    |  5 +--
 src/analyse/Elf.ml            |  8 ++---
 src/analyse/Symbols.ml        |  4 +--
 src/analyse/Utils.ml          |  2 +-
 src/bin/copySources.ml        |  4 +--
 src/dw/addr.ml                |  2 +-
 src/dw/var.ml                 |  2 +-
 src/elf/address.ml            |  2 +-
 src/elf/linksemRelocatable.ml |  2 +-
 src/utils/sym.ml              | 68 ++++++++++++++++-------------------
 10 files changed, 46 insertions(+), 53 deletions(-)

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 4c305098..bba61c63 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -139,7 +139,8 @@ let branch_table_target_addresses test filename_branch_table_option : (addr * ad
 
   (* chop into 4-byte words - as needed for branch offset tables,
      though not for all other things in .rodata *)
-  let rodata_words : (natural * natural) list = Dwarf.words_of_rel_byte_sequence rodata_addr (Dwarf.rbs_no_reloc bs) [] in (*HACK*)
+  let rodata_words : (natural * natural) list =
+    Dwarf.words_of_sym_byte_sequence rodata_addr (Dwarf_byte_sequence.sym_bs_construct bs (Pmap.empty Nat_big_num.compare)) [] in (*HACK*)
 
   let read_rodata_b addr =
     Dwarf.sym_natural_of_byte
@@ -495,7 +496,7 @@ let parse_objdump_lines arch lines : objdump_instruction list =
  *)
 
 let with_symbolic_address (section: string) (addr, opcode_bytes, mnemonic, operands) : objdump_instruction =
-  (Dwarf.Offset (section, Nat_big_num.of_int64 addr), opcode_bytes, mnemonic, operands)
+  (Sym_ocaml.Num.Offset (section, Nat_big_num.of_int64 addr), opcode_bytes, mnemonic, operands)
 
 let rec parse_objdump_lines arch lines (next_index : int) (last_address : int64 option) (section: string option) :
     objdump_instruction list =
diff --git a/src/analyse/Elf.ml b/src/analyse/Elf.ml
index 5b3bb63c..574664ca 100644
--- a/src/analyse/Elf.ml
+++ b/src/analyse/Elf.ml
@@ -58,8 +58,8 @@ let pp_symbol_map (symbol_map : Elf_file.global_symbol_init_info) =
   String.concat ""
     (List.map
        (fun (name, (typ, _size, address, _mb, _binding)) ->
-         Printf.sprintf "**** name = %s  address = %s  typ = %d\n" name (pp_addr (Dwarf.Absolute address))
-           (Sym.to_int (Dwarf.Absolute typ)))
+         Printf.sprintf "**** name = %s  address = %s  typ = %d\n" name (pp_addr (Sym_ocaml.Num.Absolute address))
+           (Sym.to_int (Sym_ocaml.Num.Absolute typ)))
        symbol_map)
 
 (*****************************************************************************)
@@ -153,8 +153,8 @@ let parse_elf_file (filename : string) : test =
         elf_file;
         arch;
         symbol_map (*@ (symbols_for_stacks !Globals.elf_threads)*);
-        e_entry = Dwarf.Absolute (entry);
-        e_machine = Dwarf.Absolute (machine);
+        e_entry = Sym_ocaml.Num.Absolute (entry);
+        e_machine = Sym_ocaml.Num.Absolute (machine);
         dwarf_static = ds;
         dwarf_semi_pp_frame_info;
       }
diff --git a/src/analyse/Symbols.ml b/src/analyse/Symbols.ml
index 360ffbf6..cc059ae4 100644
--- a/src/analyse/Symbols.ml
+++ b/src/analyse/Symbols.ml
@@ -28,7 +28,7 @@ let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_i
       | None ->
         if machine = Elf_header.elf_ma_aarch64 then
           Error.bind
-            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.abi_aarch64_relocation_to_abstract section)
+            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.aarch64_relocation_interpreter section)
             @@ fun relocs -> Error.return (AArch64 relocs)
         else
           Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
@@ -43,7 +43,7 @@ let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_i
         let bnd  = Elf_symbol_table.extract_symbol_binding entry.elf64_st_info in
         Option.map (
           fun section ->
-            let addr = Dwarf.Offset (section.elf64_section_name_as_string, addr_offset) in
+            let addr = Sym_ocaml.Num.Offset (section.elf64_section_name_as_string, addr_offset) in
             let data = if Byte_sequence.length0 section.elf64_section_body = Z.zero then
               Error.return (Byte_sequence.zeros size)
             else
diff --git a/src/analyse/Utils.ml b/src/analyse/Utils.ml
index bcd5a717..5d79072b 100644
--- a/src/analyse/Utils.ml
+++ b/src/analyse/Utils.ml
@@ -57,7 +57,7 @@ type addr = natural
 (* hackishly mask out bigint conversion failure *)
 let pp_addr (a : natural) = 
   try
-    Dwarf.pp_sym Ml_bindings.hex_string_of_big_int_pad8 a
+    Sym_ocaml.Num.ppf Ml_bindings.hex_string_of_big_int_pad8 a
   with
   | Failure s -> let s' = "Failure: int64_of_big_int " ^ Sym.to_string a in (warn "pp_addr failure: %s" s); s'
   | e -> raise e
diff --git a/src/bin/copySources.ml b/src/bin/copySources.ml
index dc30fd01..ed6def6f 100644
--- a/src/bin/copySources.ml
+++ b/src/bin/copySources.ml
@@ -84,8 +84,8 @@ let process_file () : unit =
                else
                  Some
                    (Byte_sequence.string_of_byte_sequence
-                      (rbs_unwrap (List.nth lnh.lnh_include_directories (dir - 1))))),
-              Byte_sequence.string_of_byte_sequence (rbs_unwrap lnfe.lnfe_path) ))
+                      (Dwarf_byte_sequence.sym_bs_expect_const (List.nth lnh.lnh_include_directories (dir - 1))))),
+              Byte_sequence.string_of_byte_sequence (Dwarf_byte_sequence.sym_bs_expect_const lnfe.lnfe_path) ))
       lnh.lnh_file_entries
   in
 
diff --git a/src/dw/addr.ml b/src/dw/addr.ml
index 0604a6f7..201906bf 100644
--- a/src/dw/addr.ml
+++ b/src/dw/addr.ml
@@ -1,6 +1,6 @@
 include Elf.Address
 
 let of_sym : Sym.t -> t = function
-| Dwarf.Offset (section, offset) -> { section; offset = Z.to_int offset }
+| Sym_ocaml.Num.Offset (section, offset) -> { section; offset = Z.to_int offset }
 | _ -> Raise.fail "expected section+offset"
 
diff --git a/src/dw/var.ml b/src/dw/var.ml
index e453d61b..b6010848 100644
--- a/src/dw/var.ml
+++ b/src/dw/var.ml
@@ -61,7 +61,7 @@ let rec loc_merge = function
   | [] -> []
 
 let end_addr_of_sym = function
-| Dwarf.Absolute z when Z.compare z (Z.of_int Int.max_int) > 0 -> None
+| Sym_ocaml.Num.Absolute z when Z.compare z (Z.of_int Int.max_int) > 0 -> None
 | x -> Some (Addr.of_sym x)
 
 (** Create a DWARF variable from its linksem counterpart *)
diff --git a/src/elf/address.ml b/src/elf/address.ml
index f332f31a..33da9cd8 100644
--- a/src/elf/address.ml
+++ b/src/elf/address.ml
@@ -23,4 +23,4 @@ let (<=) = compare (<=)
 
 let (>=) = compare (>=)
 
-let to_sym {section; offset} = Dwarf.Offset (section, Z.of_int offset)
\ No newline at end of file
+let to_sym {section; offset} = Sym_ocaml.Num.Offset (section, Z.of_int offset)
\ No newline at end of file
diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
index d822c2fa..99998fb7 100644
--- a/src/elf/linksemRelocatable.ml
+++ b/src/elf/linksemRelocatable.ml
@@ -30,7 +30,7 @@ let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_i
       | None ->
         if machine = Elf_header.elf_ma_aarch64 then
           Error.bind
-            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.abi_aarch64_relocation_to_abstract section)
+            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.aarch64_relocation_interpreter section)
             @@ fun relocs -> Error.return (AArch64 relocs)
         else
           Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
index 1510a8b3..42ef411d 100644
--- a/src/utils/sym.ml
+++ b/src/utils/sym.ml
@@ -1,15 +1,15 @@
-type t = Z.t Dwarf.sym0
+type t = Sym_ocaml.Num.t
 
 let pp x = x |> Dwarf.pphex_sym |> Pp.string
 
-let to_z x = Dwarf.sym_unwrap x "to_z"
+let to_z x = Sym_ocaml.Num.to_num x
 
 let to_int x = Z.to_int @@ to_z x
 
-let of_int x = Dwarf.Absolute (Z.of_int x)
-let of_int64 x = Dwarf.Absolute (Z.of_int64 x)
+let of_int x = Sym_ocaml.Num.Absolute (Z.of_int x)
+let of_int64 x = Sym_ocaml.Num.Absolute (Z.of_int64 x)
 
-let equal = Dwarf.sym_comp Nat_big_num.equal
+let equal = Sym_ocaml.Num.equal
 
 let max_addr = Z.(shift_left (of_int 1) 64 - (of_int 1))
 
@@ -17,40 +17,32 @@ let min_addr = Z.of_int 0
 
 (* TODO very hacky *)
 let less x y = match (x, y) with
-| (Dwarf.Absolute x, Dwarf.Offset (_, y)) when Nat_big_num.less x y -> true
-| (Dwarf.Absolute x, Dwarf.Offset (_,_)) when Nat_big_num.greater_equal x max_addr -> false
-| (Dwarf.Offset (_,_), Dwarf.Absolute y) when Nat_big_num.less max_addr y -> true
-| (Dwarf.Offset (_, x), Dwarf.Absolute y) when Nat_big_num.greater_equal x y -> false
-| _ -> Dwarf.sym_comp Nat_big_num.less x y
-let less_equal = Dwarf.sym_comp Nat_big_num.less_equal
-let greater = Dwarf.sym_comp Nat_big_num.greater
-let greater_equal = Dwarf.sym_comp Nat_big_num.greater_equal
-let compare = Dwarf.sym_comp Nat_big_num.compare
-
-let to_string = Dwarf.pp_sym Z.to_string
-
-let sub x y = match (x, y) with
-| (Dwarf.Offset (s, a), Dwarf.Offset (t, b)) when s = t -> Dwarf.Absolute (Nat_big_num.sub a b)
-| (Dwarf.Offset (s, a), Dwarf.Absolute b) -> Dwarf.Offset (s, Nat_big_num.sub a b)
-| (Dwarf.Absolute a, Dwarf.Absolute b) -> Dwarf.Absolute (Nat_big_num.sub a b)
-| _ -> Dwarf.Unknown
-
-let add x y = match (x, y) with
-| (Dwarf.Offset (s, a), Dwarf.Absolute b) -> Dwarf.Offset (s, Nat_big_num.add a b)
-| (Dwarf.Absolute (a), Dwarf.Offset (s,b)) -> Dwarf.Offset (s, Nat_big_num.add a b)
-| (Dwarf.Absolute a, Dwarf.Absolute b) -> Dwarf.Absolute (Nat_big_num.add a b)
-| _ -> Dwarf.Unknown
-
-let mul = Dwarf.sym_map2 Nat_big_num.mul
-
-let pow_int_positive x y = Dwarf.Absolute (Nat_big_num.pow_int_positive x y)
-
-let shift_left x s = Dwarf.sym_map (fun x -> Nat_big_num.shift_left x s) x
-let shift_right x s = Dwarf.sym_map (fun x -> Nat_big_num.shift_right x s) x
-let modulus = Dwarf.sym_map2 Nat_big_num.modulus
+| (Sym_ocaml.Num.Absolute x, Sym_ocaml.Num.Offset (_, y)) when Nat_big_num.less x y -> true
+| (Sym_ocaml.Num.Absolute x, Sym_ocaml.Num.Offset (_,_)) when Nat_big_num.greater_equal x max_addr -> false
+| (Sym_ocaml.Num.Offset (_,_), Sym_ocaml.Num.Absolute y) when Nat_big_num.less max_addr y -> true
+| (Sym_ocaml.Num.Offset (_, x), Sym_ocaml.Num.Absolute y) when Nat_big_num.greater_equal x y -> false
+| _ -> Sym_ocaml.Num.comp Nat_big_num.less x y
+let less_equal = Sym_ocaml.Num.less_equal
+let greater = Sym_ocaml.Num.greater
+let greater_equal = Sym_ocaml.Num.greater_equal
+let compare = Sym_ocaml.Num.compare
+
+let to_string = Sym_ocaml.Num.ppf Z.to_string
+
+let sub = Sym_ocaml.Num.sub
+
+let add = Sym_ocaml.Num.add
+
+let mul = Sym_ocaml.Num.mul
+
+let pow_int_positive x y = Sym_ocaml.Num.Absolute (Nat_big_num.pow_int_positive x y)
+
+let shift_left x s = Sym_ocaml.Num.map (fun x -> Nat_big_num.shift_left x s) x
+let shift_right x s = Sym_ocaml.Num.map (fun x -> Nat_big_num.shift_right x s) x
+let modulus = Sym_ocaml.Num.map2 Nat_big_num.modulus
 
 let in_range first last x = match (first, last, x) with
-| (Dwarf.Absolute f, Dwarf.Absolute l, Dwarf.Absolute x) -> Nat_big_num.less_equal f x && Nat_big_num.less_equal x l
-| (Dwarf.Offset (s1, f), Dwarf.Offset (s2, l), Dwarf.Offset (s, x)) when s1 = s2 ->
+| (Sym_ocaml.Num.Absolute f, Sym_ocaml.Num.Absolute l, Sym_ocaml.Num.Absolute x) -> Nat_big_num.less_equal f x && Nat_big_num.less_equal x l
+| (Sym_ocaml.Num.Offset (s1, f), Sym_ocaml.Num.Offset (s2, l), Sym_ocaml.Num.Offset (s, x)) when s1 = s2 ->
   s1 = s && Nat_big_num.less_equal f x && Nat_big_num.less_equal x l (* TODO kinda hacky *)
 | _ -> Raise.fail "Can't determine if %t is in range [%t,%t]" (Pp.tos pp x) (Pp.tos pp first) (Pp.tos pp last)
\ No newline at end of file

From a212415f023939605ee7d93ee69a116e07e42d6d Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Apr 2025 12:26:15 +0100
Subject: [PATCH 061/116] Test script

---
 src/bin/readDwarf.ml   |  1 +
 src/run/block_lib.ml   | 13 ++++----
 src/run/func.ml        |  9 ++++--
 src/run/relProg.ml     |  4 ++-
 src/run/testRelProg.ml | 70 ++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 88 insertions(+), 9 deletions(-)
 create mode 100644 src/run/testRelProg.ml

diff --git a/src/bin/readDwarf.ml b/src/bin/readDwarf.ml
index 60a7749f..577cac14 100644
--- a/src/bin/readDwarf.ml
+++ b/src/bin/readDwarf.ml
@@ -73,6 +73,7 @@ let commands =
     Run.Block.command;
     Run.FuncRD.command;
     Run.RelProg.command;
+    Run.TestRelProg.command;
     CopySourcesCmd.command;
     Z3.Test.command;
   ]
diff --git a/src/run/block_lib.ml b/src/run/block_lib.ml
index 3082c0c1..3b62215f 100644
--- a/src/run/block_lib.ml
+++ b/src/run/block_lib.ml
@@ -93,24 +93,25 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
   assert (State.is_locked start);
   let rec run_from state =
     let pc_exp = State.get_reg_exp state pcreg in
+    State.Simplify.ctxfull state;
     if State.is_possible state then
       match b.endpred pc_exp with
       | Some endmsg ->
           info "Stopped at pc %t because %s" (Pp.top State.Exp.pp pc_exp) endmsg;
-          State.Simplify.ctxfull state;
+          (* State.Simplify.ctxfull state; *)
           State.lock state;
           State.Tree.{ state; data = End endmsg; rest = [] }
       | None -> (
-          let prelock state = State.Simplify.ctxfull state in
+          (* let prelock state = State.Simplify.ctxfull state in *)
           if every_instruction then begin
-            prelock state;
+            (* prelock state; *)
             State.lock state
           end;
           let states =
             let pc = State.Exp.expect_sym_address pc_exp in
             if Option.fold ~none:true ~some:(Fun.flip Hashtbl.mem pc) relevant then (
               info "Running pc %t" (Pp.top State.Exp.pp pc_exp);
-              Runner.run ~prelock b.runner state
+              Runner.run ~prelock:ignore b.runner state
             )
             else (
               info "Skipping pc %t" (Pp.top State.Exp.pp pc_exp);
@@ -131,7 +132,7 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
         )
     else begin
       info "Reached dead code at %t" (Pp.top State.Exp.pp pc_exp);
-      State.Simplify.ctxfull state;
+      (* State.Simplify.ctxfull state; *)
       State.lock state;
       State.Tree.{ state; data = End "Reached dead code"; rest = [] }
     end
@@ -162,7 +163,7 @@ let gen_endpred ?min ?max ?loop ?(brks = []) () : State.exp -> string option =
     ( try
       Some (State.Exp.expect_sym_address pc_exp)
     with
-      _ -> debug "PC is sus"; None
+      _ -> None
     ) |> Option.map (fun pc ->
       debug "enpred: Evaluating PC %t" (Pp.top Elf.Address.pp pc);
       match (min, max, loop) with
diff --git a/src/run/func.ml b/src/run/func.ml
index 2c5968c4..e733d880 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -46,7 +46,7 @@
 
 open Cmdliner
 open Config.CommonOpt
-open Fun
+(* open Fun *)
 
 open Logs.Logger (struct
   let str = __MODULE__
@@ -78,7 +78,12 @@ let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(br
   | Some sym ->
       let brks =
         List.map
-          (Elf.SymTable.of_position_string elf.symbols %> Elf.SymTable.to_addr_offset)
+          (fun x ->
+            if String.starts_with ~prefix:"UND" x then (*HACK for undefined symbol*)
+              Elf.Address.{ section=x; offset=0 }
+            else
+              x |> Elf.SymTable.of_position_string elf.symbols |> Elf.SymTable.to_addr_offset
+          )
           breakpoints
       in
       let (min, max) =
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index e375db07..7bf90660 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -124,7 +124,9 @@ let run_prog elfname name objdump_d branchtables =
       instr
   in
   base "Start running";
-  let tree = Func.get_state_tree ~elf:elfname ~name ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:true () in
+  let tree = Func.get_state_tree ~elf:elfname ~name ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:true ()
+    ~breakpoints:["UND.abort"; "UND.exit"]
+  in
   base "Ended running, start pretty printing";
   (* This table will contain the state diff to print at each pc with a message *)
   (* let instr_data : (Elf.Address.t, string * State.t * State.Reg.t list) Hashtbl.t =
diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
new file mode 100644
index 00000000..1a429422
--- /dev/null
+++ b/src/run/testRelProg.ml
@@ -0,0 +1,70 @@
+open Cmdliner
+open Config.CommonOpt
+
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
+let test return_register exit_register name =
+  let tree = Func.get_state_tree ~elf:name ~name:"main" ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:false ()
+    ~breakpoints:["UND.abort"; "UND.exit"]
+  in
+  let pc = Arch.pc () in
+  let ret = State.Reg.of_string return_register in
+  let ext = State.Reg.of_string exit_register in
+  State.Tree.iter (fun l st ->
+    if State.is_possible st then
+      match l with
+      | Block_lib.End _ -> (
+          let pc_exp = State.get_reg_exp st pc in
+          let ret_exp = match (try
+              Some (State.Exp.expect_sym_address pc_exp)
+            with
+              _ -> None
+            ) with
+              | Some pc_addr ->
+                if pc_addr = Elf.Address.{ section="UND.abort"; offset=0 } then
+                  fail "abort called from %t" (Pp.top Elf.Address.pp st.last_pc)
+                else if pc_addr <> Elf.Address.{ section="UND.exit"; offset=0 } then
+                  fail "finished at weird address %t" (Pp.top Elf.Address.pp pc_addr)
+                else
+                  State.get_reg_exp st ext
+              | None ->
+                State.get_reg_exp st ret (* Symbolic pc = returned from main *)
+          in
+          let ret_val = ret_exp |> Exp.ConcreteEval.eval |> Exp.Value.expect_bv |> BitVec.to_int in
+          if ret_val <> 0 then
+            fail "non-zero return code %d" ret_val;
+      )
+      | _ -> ()
+  ) tree;
+  base "Success"
+
+let elf =
+  let doc = "ELF file from which to pull the code" in
+  Arg.(required & pos 0 (some non_dir_file) None & info [] ~docv:"ELF_FILE" ~doc)
+
+let return_register =
+  let doc = "The name of the register containing the return value of main function" in
+  Arg.(value & opt string "R0" & info ["r"] ~docv:"RETURN_REGISTER" ~doc)
+
+let exit_register =
+  let doc = "The name of the register containing the argument to exit function" in
+  Arg.(value & opt string "R0" & info ["e"] ~docv:"EXIT_REGISTER" ~doc)
+  
+
+let term =
+  Term.(
+    CmdlinerHelper.func_options comopts test
+    $ return_register $ exit_register $ elf)
+
+let info =
+  let doc =
+    "Test run relocatable file\
+    
+    Test succeeds if all possble outcomes result in the program exiting with\
+    with code 0"
+  in
+  Cmd.(info "test-rel-prog" ~doc ~exits)
+
+let command = (term, info)

From a77a87b2ea128fe8698fbf90d3599a7112a1537b Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Apr 2025 12:36:59 +0100
Subject: [PATCH 062/116] Fix rodata

---
 src/elf/file.ml   | 2 +-
 src/state/base.ml | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index d628ed8f..1b56d28f 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -146,7 +146,7 @@ let of_file (filename : string) =
     Segment.
       {
         data;
-        addr = Sym.to_int addr; (* TODO *)
+        addr = 0; (* Meaningless for relocatable files *)
         size = BytesSeq.length data;
         read = true;
         write = false;
diff --git a/src/state/base.ml b/src/state/base.ml
index eebb0ace..2aa43a6c 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -589,8 +589,7 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
   | Some elf -> (
       if not @@ ConcreteEval.is_concrete addr then None
       else
-        let int_addr = ConcreteEval.eval addr |> Value.expect_bv |> BitVec.to_int in
-        let sym_addr = Elf.Address.{ section = ".rodata"; offset = int_addr } in (* TODO this is wrong *)
+        let sym_addr = Exp.expect_sym_address addr in
         let size = size |> Ast.Size.to_bits in
         try
           let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols sym_addr in
@@ -600,13 +599,14 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
             let bv = BytesSeq.getbvle ~size sym.data.data offset in (* TODO relocations *)
             Some (Typed.bits bv)
         with Not_found ->
+          let int_addr = sym_addr.offset in
           let rodata = elf.rodata in
-          if rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size then
+          if sym_addr.section = ".rodata" && rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size then
             let bv = BytesSeq.getbvle ~size rodata.data (int_addr - rodata.addr) in
             (* Assume little endian here *)
             Some (Typed.bits bv)
           else (
-            warn "Failed to find symbol or rodata at 0x%x" int_addr;
+            warn "Failed to find symbol or rodata at %t" (Pp.top Elf.Address.pp sym_addr);
             None
           )
     )

From c5e2b56433f14a21acf90e87dae0da9dce6deb50 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Apr 2025 13:12:56 +0100
Subject: [PATCH 063/116] Fix loading objects

---
 src/state/base.ml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 2aa43a6c..458a3114 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -531,11 +531,11 @@ let init_sections ~addr_size state =
   let _ = Option.(
     let+ elf = state.elf in
     Elf.SymTable.iter elf.symbols @@ fun sym ->
+      let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
       if sym.typ = Elf.Symbol.OBJECT then
         let provenance = Mem.create_section_frag ~addr_size state.mem sym.addr.section in
-        Seq.iota_step_up ~step:16 ~endi:sym.size
+        Seq.iota_step_up ~step:len ~endi:sym.size
         |> Seq.iter (fun off ->
-          let len = min 16 (sym.size - off) in
           let data = Elf.Symbol.sub sym off len in
           let addr = Exp.of_address ~size:addr_size Elf.Address.(sym.addr + off) in
           let size = Ast.Size.of_bytes len in

From 2bc6c015396547af9d59bb48f052ac0e011ca40a Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Apr 2025 15:46:32 +0100
Subject: [PATCH 064/116] Fix reading rodata

Also fixes a bug in read_from_rodata of comparing
sizes in bits vs bytes
---
 src/run/testRelProg.ml |  1 +
 src/state/base.ml      | 73 +++++++++++++++++++++---------------------
 2 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
index 1a429422..1f4b396d 100644
--- a/src/run/testRelProg.ml
+++ b/src/run/testRelProg.ml
@@ -9,6 +9,7 @@ let test return_register exit_register name =
   let tree = Func.get_state_tree ~elf:name ~name:"main" ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:false ()
     ~breakpoints:["UND.abort"; "UND.exit"]
   in
+  debug "%t" (Pp.top (State.Tree.pp_all Block_lib.pp_label) tree);
   let pc = Arch.pc () in
   let ret = State.Reg.of_string return_register in
   let ext = State.Reg.of_string exit_register in
diff --git a/src/state/base.ml b/src/state/base.ml
index 458a3114..2099b52b 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -583,43 +583,6 @@ let set_read (s : t) (read_num : int) (exp : Exp.t) =
   assert (Typed.get_type exp = Typed.get_type (Vec.get s.read_vars read_num |> Tval.exp));
   Vec.update s.read_vars read_num @@ Tval.map_exp (Fun.const exp)
 
-let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option =
-  match s.elf with
-  | None -> None
-  | Some elf -> (
-      if not @@ ConcreteEval.is_concrete addr then None
-      else
-        let sym_addr = Exp.expect_sym_address addr in
-        let size = size |> Ast.Size.to_bits in
-        try
-          let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols sym_addr in
-          if sym.writable then None
-          else
-            (* Assume little endian here *)
-            let bv = BytesSeq.getbvle ~size sym.data.data offset in (* TODO relocations *)
-            Some (Typed.bits bv)
-        with Not_found ->
-          let int_addr = sym_addr.offset in
-          let rodata = elf.rodata in
-          if sym_addr.section = ".rodata" && rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size then
-            let bv = BytesSeq.getbvle ~size rodata.data (int_addr - rodata.addr) in
-            (* Assume little endian here *)
-            Some (Typed.bits bv)
-          else (
-            warn "Failed to find symbol or rodata at %t" (Pp.top Elf.Address.pp sym_addr);
-            None
-          )
-    )
-
-let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
-  assert (not @@ is_locked s);
-  let var = make_read ?ctyp s size in
-  let exp = Mem.read s.mem ~provenance ~var ~addr ~size in
-  let exp = if provenance = Main && exp = None then read_from_rodata ~addr ~size s else exp in
-  Option.iter (set_read s (Var.expect_readvar var)) exp;
-  Option.value exp ~default:(Exp.of_var var)
-
-
 let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
   let ctxt0 = function Var.Section _ -> Value.bv @@ BitVec.of_int ~size:64 0 | _ -> raise ConcreteEval.Symbolic in
   let open Option in
@@ -643,6 +606,42 @@ let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
       None
   )
   
+let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option =
+  debug "reading from rodata at address: %t" (Pp.top Exp.pp addr);
+  match s.elf with
+  | None -> None
+  | Some elf -> (
+      Option.bind (eval_address s addr) @@ fun sym_addr ->
+      let size = size |> Ast.Size.to_bits in
+      try
+        let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols sym_addr in
+        if sym.writable then None
+        else (
+          (* Assume little endian here *)
+          assert (Relocation.IMap.is_empty sym.data.relocations);
+          let bv = BytesSeq.getbvle ~size sym.data.data offset in (* TODO relocations *)
+          Some (Typed.bits bv)
+        )
+      with Not_found ->
+        let int_addr = sym_addr.offset in
+        let rodata = elf.rodata in
+        if sym_addr.section = ".rodata" && rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size * 8 then
+          let bv = BytesSeq.getbvle ~size rodata.data (int_addr - rodata.addr) in
+          (* Assume little endian here *)
+          Some (Typed.bits bv)
+        else (
+          warn "Failed to find symbol or rodata at %t" (Pp.top Elf.Address.pp sym_addr);
+          None
+        )
+    )
+
+let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+  assert (not @@ is_locked s);
+  let var = make_read ?ctyp s size in
+  let exp = Mem.read s.mem ~provenance ~var ~addr ~size in
+  let exp = if provenance = Main && exp = None then read_from_rodata ~addr ~size s else exp in
+  Option.iter (set_read s (Var.expect_readvar var)) exp;
+  Option.value exp ~default:(Exp.of_var var)
 
 let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
   debug "Addr: %t" Pp.(top Exp.pp addr);

From c1c5cc5bcd95adb4a6c8f3826bd1e8410c6a28e8 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Apr 2025 16:34:17 +0100
Subject: [PATCH 065/116] Multiple rodata sections

---
 src/elf/file.ml   | 44 ++++++++++++++++++++++++++++----------------
 src/state/base.ml |  5 +++--
 2 files changed, 31 insertions(+), 18 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index 1b56d28f..6acffd47 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -75,6 +75,8 @@ let machine_to_string = function
 (** Pretty prints a {!machine} *)
 let pp_machine mach = mach |> machine_to_string |> Pp.string
 
+module SMap = Map.Make(String)
+
 (** The type containing all the information about an ELF file *)
 type t = {
   filename : string;  (** The name on the file system. Useful for error messages *)
@@ -84,7 +86,7 @@ type t = {
       (** The target architecture of the file; only used in [arch.ml, dumpSym.ml, dw.ml] *)
   linksem : Elf_file.elf_file;
       (** The original linksem structure for the file; only used in  [dw.ml] *)
-  rodata : Segment.t;  (** The read-only data section *)
+  rodata : Segment.t SMap.t;  (** The read-only data sections *)
 }
 
 (** Error on Elf parsing *)
@@ -137,21 +139,31 @@ let of_file (filename : string) =
        within it, and so not suitable to be stored in the [RngMap] *)
   let elf_file = Elf_file.ELF_File_64 elf64_file in
   let rodata =
-    let (_, addr, data) =
-      Dwarf.extract_section_body_without_relocations elf_file ".rodata" false
-      (* `false' argument is for returning an empty byte-sequence if
-         section is not found, instead of throwing an exception *)
-    in
-    Printf.printf "%t" Pp.(top Sym.pp addr);
-    Segment.
-      {
-        data;
-        addr = 0; (* Meaningless for relocatable files *)
-        size = BytesSeq.length data;
-        read = true;
-        write = false;
-        execute = false;
-      }
+    SMap.of_list @@ List.filter_map Option.(fun (section:Elf_interpreted_section.elf64_interpreted_section) ->
+      let+ sname = if String.starts_with ~prefix:".rodata" section.elf64_section_name_as_string then
+        Some section.elf64_section_name_as_string
+      else
+        None
+      in
+      let (_, addr, data) =
+        Dwarf.extract_section_body_without_relocations elf_file sname false
+        (* `false' argument is for returning an empty byte-sequence if
+          section is not found, instead of throwing an exception *)
+      in
+      Printf.printf "%t" Pp.(top Sym.pp addr);
+      (
+        sname,
+        Segment.
+        {
+          data;
+          addr = 0; (* Meaningless for relocatable files *)
+          size = BytesSeq.length data;
+          read = true;
+          write = false;
+          execute = false;
+        }
+      )
+    ) elf64_file.elf64_file_interpreted_sections
   in
   info "ELF file %s has been loaded" filename;
   { filename; symbols; entry; machine; linksem = elf_file; rodata }
diff --git a/src/state/base.ml b/src/state/base.ml
index 2099b52b..28f7d087 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -624,8 +624,9 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
         )
       with Not_found ->
         let int_addr = sym_addr.offset in
-        let rodata = elf.rodata in
-        if sym_addr.section = ".rodata" && rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size * 8 then
+        let open Option in
+        let* rodata = Elf.File.SMap.find_opt sym_addr.section elf.rodata in
+        if rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size * 8 then
           let bv = BytesSeq.getbvle ~size rodata.data (int_addr - rodata.addr) in
           (* Assume little endian here *)
           Some (Typed.bits bv)

From 1ed0c5ccff3561e97a70d71a4ea49fe002b8faa3 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Apr 2025 17:45:41 +0100
Subject: [PATCH 066/116] Generate section address constraints

---
 src/run/func.ml    |  2 +-
 src/state/base.ml  | 10 +++++++++-
 src/state/base.mli |  2 +-
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/run/func.ml b/src/run/func.ml
index e733d880..4ea1d385 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -52,7 +52,7 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic) () =
+let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic ~addr_size:Arch.address_size) () =
   base "Running %s in %s" name elfname;
   let dwarf = Dw.of_file elfname in
   let elf = dwarf.elf in
diff --git a/src/state/base.ml b/src/state/base.ml
index 28f7d087..077f2ac4 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -531,6 +531,10 @@ let init_sections ~addr_size state =
   let _ = Option.(
     let+ elf = state.elf in
     Elf.SymTable.iter elf.symbols @@ fun sym ->
+      let max_section_addr = Int.shift_left 1 addr_size - sym.size - sym.addr.offset in
+      push_assert state Typed.(
+        comp Ast.Bvule (Exp.of_var (Var.Section sym.addr.section)) (bits_int ~size:64 max_section_addr)
+      );
       let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
       if sym.typ = Elf.Symbol.OBJECT then
         let provenance = Mem.create_section_frag ~addr_size state.mem sym.addr.section in
@@ -546,11 +550,15 @@ let init_sections ~addr_size state =
   ) in
   state
 
-let init_sections_symbolic state =
+let init_sections_symbolic ~addr_size state =
   let state = copy_if_locked state in
   let _ = Option.(
     let+ elf = state.elf in
     Elf.SymTable.iter elf.symbols @@ fun sym ->
+      let max_section_addr = Int.shift_left 1 addr_size - sym.size - sym.addr.offset in
+      push_assert state Typed.(
+        comp Ast.Bvule (Exp.of_var (Var.Section sym.addr.section)) (bits_int ~size:64 max_section_addr)
+      );
       if sym.typ = Elf.Symbol.OBJECT then
         Hashtbl.replace state.mem.sections sym.addr.section Main
   ) in
diff --git a/src/state/base.mli b/src/state/base.mli
index 73f123db..1877b17d 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -405,7 +405,7 @@ val copy_if_locked : ?elf:Elf.File.t -> t -> t
 val init_sections : addr_size:int -> t -> t
 
 (** Assigns all sections with global objects to Main fragment *)
-val init_sections_symbolic : t -> t
+val init_sections_symbolic : addr_size:int -> t -> t
 
 
 (** {1 State convenience manipulation } *)

From 65a7e044b98ab53d6c686c30820688ec6e8dfef1 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 11 Apr 2025 10:05:16 +0100
Subject: [PATCH 067/116] Fix nondet

---
 src/state/base.ml    |  7 +++++++
 src/state/base.mli   |  3 +++
 src/trace/context.ml | 11 +++++++++--
 3 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 077f2ac4..30dc867e 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -62,6 +62,8 @@ end
 type id = Id.t
 
 module Var = struct
+  let next_nondet = ref 0
+
   type t =
     | Register of Id.t * Reg.t  (** The value of this register in this state *)
     | ReadVar of Id.t * int * Ast.Size.t
@@ -159,6 +161,11 @@ module Var = struct
     | RetAddr -> Ast.Ty_BitVec 64
     | NonDet (_, size) -> Ast.Ty_BitVec (Ast.Size.to_bits size)
     | Section _ -> Ast.Ty_BitVec 64
+
+  let new_nondet sz =
+    let v = NonDet (!next_nondet, sz) in
+    next_nondet := !next_nondet + 1;
+    v
 end
 
 type var = Var.t
diff --git a/src/state/base.mli b/src/state/base.mli
index 1877b17d..a7275a7e 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -145,6 +145,9 @@ module Var : sig
 
   (** Get the type of a variable *)
   val ty : t -> Reg.ty
+
+  (** Get a fresh NonDet variable *)
+  val new_nondet : Ast.Size.t -> t
 end
 
 (** The type of variables *)
diff --git a/src/trace/context.ml b/src/trace/context.ml
index f233abe9..2fe350d4 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -58,6 +58,7 @@ module SMap = Map.Make (String)
 type t = {
   reg_writes : (State.Reg.t * State.tval) Vec.t;  (** Stores the delayed register writes *)
   mem_reads : State.tval HashVector.t;  (** Stores the result of memory reads *)
+  nondets : State.var HashVector.t;  (** Stores the mapping of nondet variables *)
   state : State.t;
   segments : State.exp SMap.t;
   asserts: State.exp list;
@@ -68,6 +69,7 @@ type t = {
 let make_context ?dwarf ?relocation state =
   let reg_writes = Vec.empty () in
   let mem_reads = HashVector.empty () in
+  let nondets = HashVector.empty () in
 
   let segments, asserts = relocation
     |> Option.map (fun relocation ->
@@ -82,14 +84,19 @@ let make_context ?dwarf ?relocation state =
       )
     |> Option.value ~default:(SMap.empty, [])
   in
-  { state; reg_writes; mem_reads; dwarf; segments; asserts }
+  { state; reg_writes; mem_reads; nondets; dwarf; segments; asserts }
 
 (** Expand a Trace variable to a State expression, using the context *)
 let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
   assert (Base.Var.ty v = a);
   match v with
   | Register reg -> State.get_reg_exp ctxt.state reg
-  | NonDet (i, _) | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
+  | NonDet (i, sz) -> HashVector.get_opt ctxt.nondets i
+    |> Option.value_fun ~default:(fun () -> 
+      Fun.tee (HashVector.add ctxt.nondets i) (State.Var.new_nondet sz)
+    )
+    |> State.Exp.of_var
+  | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
   | Segment (name, _) -> SMap.find name ctxt.segments (*TODO put the actual value there*)
   (* | Segment (name, sz) -> Exp.Typed.extract ~first:0 ~last:(sz-1) (State.Exp.of_var (State.Var.Section name)) TODO put the actual value there *)
 

From 9c760c08286ada49bafce5a3cd8c13dfd6726d34 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 11 Apr 2025 10:36:29 +0100
Subject: [PATCH 068/116] Fix symbolic bytes subranges

Subranges were extracted as little and concatenated as big endian
Now both are little endian
---
 src/state/symbolicBytes.ml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/state/symbolicBytes.ml b/src/state/symbolicBytes.ml
index 2693b0b3..07a43622 100644
--- a/src/state/symbolicBytes.ml
+++ b/src/state/symbolicBytes.ml
@@ -126,6 +126,7 @@ module Make (Var : Exp.Var) : S with type var = Var.t = struct
     assert (pos + len <= elen);
     (Typed.extract ~last:((8 * (pos + len)) - 1) ~first:(8 * pos) e, len)
 
+  (* TODO should we care about endianness? *)
   (* Warning: This code is complicated because of all the indices. I tried to make diagrams
      to explain *)
   let sub ~pos ~len sb =
@@ -166,7 +167,7 @@ module Make (Var : Exp.Var) : S with type var = Var.t = struct
           Some [Typed.extract ~last:((8 * taken_len) - 1) ~first:(8 * off) e]
     in
     let+ list = sub_list ~pos ~len sb in
-    Typed.concat list
+    Typed.concat @@ List.rev list
 
   let blit_exp exp ~pos ~len sb =
     assert (len > 0);

From 63d3ebb1461f1b44ae43c4ea191520bb95d623b9 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 11 Apr 2025 13:23:58 +0100
Subject: [PATCH 069/116] Hack addres-size extract of constexpr

---
 src/trace/typer.ml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index 238a17ef..25dc0a92 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -106,11 +106,13 @@ let unop (u : Ast.unop) tval : Ctype.t option =
   | Bvneg | Bvnot -> machine_of_size typ |> some
   | Extract (b, a) ->
       debug "Extracting from type %t" Pp.(top (opt Ctype.pp) tval.ctyp);
-      if (* HACK for adrp: a = 0 && b = Arch.address_size - 1 &&*) Ctype.is_ptr typ then tval.ctyp
+      if (* HACK for adrp: a = 0 && b = Arch.address_size - 1 &&*) Ctype.is_ptr typ then
+        tval.ctyp
       else
         let bitsize = b - a + 1 in
         let constexpr = typ.constexpr in
-        if bitsize mod 8 = 0 then Ctype.machine ~constexpr (bitsize / 8) |> some else None
+        if bitsize mod 8 = 0 || bitsize = Arch.address_size && constexpr then
+          Ctype.machine ~constexpr (bitsize / 8) |> some else None
   | ZeroExtend m | SignExtend m ->
       if m mod 8 = 0 then machine_of_size ~update:(m / 8) typ |> some else None
 

From 34b6c323a705cce2ce1643724f0215202ac2f37a Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 11 Apr 2025 13:33:33 +0100
Subject: [PATCH 070/116] Testing: Warn about read variables

---
 src/run/testRelProg.ml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
index 1f4b396d..067e3799 100644
--- a/src/run/testRelProg.ml
+++ b/src/run/testRelProg.ml
@@ -14,6 +14,14 @@ let test return_register exit_register name =
   let ret = State.Reg.of_string return_register in
   let ext = State.Reg.of_string exit_register in
   State.Tree.iter (fun l st ->
+    let found_symread = ref false in
+    st.read_vars |> Vec.iter Fun.(State.Tval.exp %> Ast.Manip.exp_iter_var (fun v ->
+      match v with
+      | State.Var.ReadVar _ -> found_symread := true; warn "State contains symbolic read variable:\n %t" (Pp.top State.Var.pp v)
+      | _ -> ()
+    ));
+    if !found_symread then
+      warn "State:\n%t" (Pp.top State.pp st);
     if State.is_possible st then
       match l with
       | Block_lib.End _ -> (

From d65c184a7642a5edffdf73f9893c5555386bc2ea Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 11 Apr 2025 14:33:31 +0100
Subject: [PATCH 071/116] More typer hacking

New bits type for bit fragments that are not whole-byte size
---
 src/ctype/ctype.ml |  3 +++
 src/run/relProg.ml |  1 +
 src/trace/typer.ml | 52 +++++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 51 insertions(+), 5 deletions(-)

diff --git a/src/ctype/ctype.ml b/src/ctype/ctype.ml
index 1c876f37..dbbe61f8 100644
--- a/src/ctype/ctype.ml
+++ b/src/ctype/ctype.ml
@@ -120,6 +120,7 @@ type unqualified =
   | Enum of { name : string; id : int }  (** See {!env} for what the id refers to *)
   | FuncPtr  (** Hack to accommodate PKVM *)
   | Missing  (** Hack to accommodate PKVM *)
+  | Bits (** Hack to prevent losing type information when processing bitvectors with non-whole-byte sizes *)
 
 (** The internal representation of generalized C types *)
 and t = {
@@ -337,6 +338,7 @@ let rec sizeof_unqualified = function
   | Array { elem; dims } ->
       let num = dims |> List.map (Option.value ~default:0) |> List.fold_left ( * ) 1 in
       num * sizeof elem
+  | Bits -> 0 (* Shouldn't use this value *)
 
 (** Give the size of an type. Need the environement. *)
 and sizeof t = sizeof_unqualified t.unqualified
@@ -660,6 +662,7 @@ and pp_unqualified = function
   | Enum { name; _ } -> dprintf "Enum %s" name
   | FuncPtr -> dprintf "FuncPtr"
   | Missing -> dprintf "Missing"
+  | Bits -> dprintf "Bits"
 
 and pp_fragment frag =
   group
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 7bf90660..7170b132 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -39,6 +39,7 @@ let pp_typed ~(tenv: Ctype.env) ~(ctype: Ctype.t) ~pp (value: State.Exp.t) =
   | Enum _ -> pp value
   | FuncPtr -> pp value
   | Missing -> pp value
+  | Bits -> pp value
 
 let read_big st addr sz =
   Seq.iota_step_up ~step:16 ~endi:sz
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index 25dc0a92..2dd8e1a2 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -98,6 +98,24 @@ let machine_of_size ?(update = 0) (typ : Ctype.t) : Ctype.t =
   let constexpr = typ.constexpr in
   Ctype.machine ~constexpr (size + update)
 
+let is_const tval =
+  tval.ctyp
+  |> Option.map Ctype.is_constexpr
+  |> Option.value_fun ~default:(fun () -> Exp.ConcreteEval.is_concrete tval.exp)
+
+let constexpr_of_exp e =
+  let ty = Exp.Typed.get_type e in
+  if Exp.Typed.is_bv ty then
+    let bitsize = Exp.Typed.expect_bv ty in
+    Option.some @@
+    if bitsize mod 8 = 0 || bitsize = Arch.address_size then
+      Ctype.machine ~constexpr:true (bitsize / 8)
+    else
+      Ctype.Bits |> Ctype.qual ~constexpr:true
+  else
+    None
+
+
 let unop (u : Ast.unop) tval : Ctype.t option =
   let open Option in
   let* typ = tval.ctyp in
@@ -111,8 +129,7 @@ let unop (u : Ast.unop) tval : Ctype.t option =
       else
         let bitsize = b - a + 1 in
         let constexpr = typ.constexpr in
-        if bitsize mod 8 = 0 || bitsize = Arch.address_size && constexpr then
-          Ctype.machine ~constexpr (bitsize / 8) |> some else None
+        if bitsize mod 8 = 0 then Ctype.machine ~constexpr (bitsize / 8) |> some else None
   | ZeroExtend m | SignExtend m ->
       if m mod 8 = 0 then machine_of_size ~update:(m / 8) typ |> some else None
 
@@ -214,12 +231,37 @@ let rec expr ~ctxt (exp : Base.exp) : Ctype.t option =
     | Bool _ -> None
     | Enum _ -> None
     | Vec _ -> None
-    | Unop (u, e, _) -> expr_tval ~ctxt e |> unop u
+    | Unop (u, e, _) ->
+        let tval = expr_tval ~ctxt e in
+        Option.(
+          unop u tval
+          |||
+          if is_const tval then
+            constexpr_of_exp exp
+          else
+            None
+        )
     | Binop (b, e, e', _) ->
         let te = expr_tval ~ctxt e in
         let te' = expr_tval ~ctxt e' in
-        binop ~ctxt b te te'
-    | Manyop (m, el, _) -> List.map (expr_tval ~ctxt) el |> manyop ~ctxt m
+        Option.(
+          binop ~ctxt b te te'
+          |||
+          if is_const te && is_const te' then
+            constexpr_of_exp exp
+          else
+            None
+        )
+    | Manyop (m, el, _) ->
+        let tvals = List.map (expr_tval ~ctxt) el in
+        Option.(
+          manyop ~ctxt m tvals
+          |||
+          if List.for_all is_const tvals then
+            constexpr_of_exp exp
+          else
+            None
+        )
     | Ite _ -> None
     | Bound _ -> .
     | Let _ -> .

From af5e7fe5ab2b500d71fe742c961c6c73bba0e1ee Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 14 Apr 2025 10:18:22 +0100
Subject: [PATCH 072/116] Better section asserts

---
 src/elf/file.ml   | 23 ++++++++++++++++++-----
 src/state/base.ml | 32 ++++++++++++++++++++++++--------
 2 files changed, 42 insertions(+), 13 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index 6acffd47..3dcc5291 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -77,6 +77,12 @@ let pp_machine mach = mach |> machine_to_string |> Pp.string
 
 module SMap = Map.Make(String)
 
+type section = {
+  name : string;
+  size : int;
+  align : int;
+}
+
 (** The type containing all the information about an ELF file *)
 type t = {
   filename : string;  (** The name on the file system. Useful for error messages *)
@@ -87,6 +93,7 @@ type t = {
   linksem : Elf_file.elf_file;
       (** The original linksem structure for the file; only used in  [dw.ml] *)
   rodata : Segment.t SMap.t;  (** The read-only data sections *)
+  sections : section list;
 }
 
 (** Error on Elf parsing *)
@@ -138,10 +145,16 @@ let of_file (filename : string) =
      - the range of the section is guaranteed to overlap with any symbols
        within it, and so not suitable to be stored in the [RngMap] *)
   let elf_file = Elf_file.ELF_File_64 elf64_file in
+  let sections = List.map (fun (s:Elf_interpreted_section.elf64_interpreted_section) -> {
+    name=s.elf64_section_name_as_string;
+    size=Z.to_int s.elf64_section_size;
+    align=Z.to_int s.elf64_section_align;
+  }) elf64_file.elf64_file_interpreted_sections
+  in
   let rodata =
-    SMap.of_list @@ List.filter_map Option.(fun (section:Elf_interpreted_section.elf64_interpreted_section) ->
-      let+ sname = if String.starts_with ~prefix:".rodata" section.elf64_section_name_as_string then
-        Some section.elf64_section_name_as_string
+    SMap.of_list @@ List.filter_map Option.(fun section ->
+      let+ sname = if String.starts_with ~prefix:".rodata" section.name then
+        Some section.name
       else
         None
       in
@@ -163,7 +176,7 @@ let of_file (filename : string) =
           execute = false;
         }
       )
-    ) elf64_file.elf64_file_interpreted_sections
+    ) sections
   in
   info "ELF file %s has been loaded" filename;
-  { filename; symbols; entry; machine; linksem = elf_file; rodata }
+  { filename; symbols; entry; machine; linksem = elf_file; rodata; sections }
diff --git a/src/state/base.ml b/src/state/base.ml
index 30dc867e..d6e93053 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -533,15 +533,34 @@ let set_impossible state =
   assert (not @@ is_locked state);
   state.asserts <- [Typed.false_]
 
+let push_section_constraints ~addr_size state sections =
+  List.iter (fun (s:Elf.File.section) ->
+    let max_section_addr = Int.shift_left 1 addr_size - s.size in
+    let s_exp = (Exp.of_var (Var.Section s.name)) in
+    (* The whole section fits in memory *)
+    push_assert state Typed.(comp Ast.Bvule s_exp (bits_int ~size:64 max_section_addr));
+    (* The load address cannot be 0 *)
+    push_assert state Typed.(not (s_exp = (bits_int ~size:64 0)));
+    if s.align > 1 then
+      let (align_pow, _) = Seq.ints 0
+      |> Seq.drop_while (fun x -> Int.shift_left 1 x < s.align)
+      |> Seq.uncons
+      |> Option.get
+      in
+      if s.align = Int.shift_left 1 align_pow then
+        let last = align_pow - 1 in
+        (* Section address is aligned *)
+        push_assert state Typed.(extract ~first:0 ~last s_exp = zero ~size:align_pow)
+      else
+        warn "Section alignment is not a power of two: %d" s.align;
+  ) sections
+
 let init_sections ~addr_size state =
   let state = copy_if_locked state in
   let _ = Option.(
     let+ elf = state.elf in
+    push_section_constraints ~addr_size state elf.sections;
     Elf.SymTable.iter elf.symbols @@ fun sym ->
-      let max_section_addr = Int.shift_left 1 addr_size - sym.size - sym.addr.offset in
-      push_assert state Typed.(
-        comp Ast.Bvule (Exp.of_var (Var.Section sym.addr.section)) (bits_int ~size:64 max_section_addr)
-      );
       let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
       if sym.typ = Elf.Symbol.OBJECT then
         let provenance = Mem.create_section_frag ~addr_size state.mem sym.addr.section in
@@ -561,11 +580,8 @@ let init_sections_symbolic ~addr_size state =
   let state = copy_if_locked state in
   let _ = Option.(
     let+ elf = state.elf in
+    push_section_constraints ~addr_size state elf.sections;
     Elf.SymTable.iter elf.symbols @@ fun sym ->
-      let max_section_addr = Int.shift_left 1 addr_size - sym.size - sym.addr.offset in
-      push_assert state Typed.(
-        comp Ast.Bvule (Exp.of_var (Var.Section sym.addr.section)) (bits_int ~size:64 max_section_addr)
-      );
       if sym.typ = Elf.Symbol.OBJECT then
         Hashtbl.replace state.mem.sections sym.addr.section Main
   ) in

From 22996d3917b72d825e3ed5a70383493fa454cd6c Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 14 Apr 2025 18:32:05 +0100
Subject: [PATCH 073/116] Better logs

---
 src/run/relProg.ml     |  19 +++++--
 src/run/testRelProg.ml | 111 ++++++++++++++++++++++++++++-------------
 src/state/simplify.ml  |  11 +++-
 3 files changed, 99 insertions(+), 42 deletions(-)

diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 7170b132..bb7b2edf 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -41,12 +41,15 @@ let pp_typed ~(tenv: Ctype.env) ~(ctype: Ctype.t) ~pp (value: State.Exp.t) =
   | Missing -> pp value
   | Bits -> pp value
 
-let read_big st addr sz =
+let read_big ~prov st addr sz =
+  let addr = Exp.Typed.extract ~last:(Arch.address_size-1) ~first:0 addr in
   Seq.iota_step_up ~step:16 ~endi:sz
   |> Seq.map (fun off ->
     let addr = Exp.Typed.(addr + bits_int ~size:Arch.address_size off) in
     let len = min 16 (sz - off) in
-    State.read_noprov st ~addr ~size:(Ast.Size.of_bytes len)
+    match prov with
+    | None -> State.read_noprov st ~addr ~size:(Ast.Size.of_bytes len)
+    | Some p -> State.read ~provenance:p st ~addr:addr ~size:(Ast.Size.of_bytes len)
   )
   |> List.of_seq
   |> Exp.Typed.concat
@@ -55,14 +58,20 @@ let pp_eval_loc sz st ~(tenv: Ctype.env) ~(ctype: Ctype.t) (loc: Dw.Loc.t) : PPr
   let value = match loc with
   | Register reg -> Some (State.get_reg_exp st reg)
   | RegisterOffset (reg, off) ->
-      let r = State.get_reg_exp st reg in
-      Some (read_big st Exp.Typed.(r + bits_int ~size:Arch.address_size off) sz)
+      let r = State.get_reg st reg in
+      let open Ctype in
+      let prov = Option.bind r.ctyp (fun ctype ->
+        match ctype.unqualified with
+        | Ptr { provenance; _ } -> Some provenance
+        | _ -> None
+      ) in
+      Some (read_big ~prov st Exp.Typed.(r.exp + bits_int ~size:64 off) sz)
   | StackFrame _off -> 
       None
   | Global symoff -> 
       let addr = Elf.SymTable.to_addr_offset symoff in
       let addr = State.Exp.of_address ~size:Arch.address_size addr in
-      Some (read_big st addr sz)
+      Some (read_big ~prov:None st addr sz)
   | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
   | Dwarf _ops -> None in
   let pp = fun value ->
diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
index 067e3799..3ac67b19 100644
--- a/src/run/testRelProg.ml
+++ b/src/run/testRelProg.ml
@@ -5,6 +5,75 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
+type err = { msg: string; asserts: State.Exp.t list }
+type node_result = { all_fail: bool; errors: err list }
+let node_result_of_result = function
+| Ok () -> { all_fail=false; errors=[] }
+| Error e -> { all_fail=true; errors=[e] }
+
+let rec process_tree ~pc ~ret ~ext (node:Block_lib.label State.Tree.t) =
+  let l = node.data in
+  let st = node.state in
+
+  let found_symread = ref false in
+  st.read_vars |> Vec.iter Fun.(State.Tval.exp %> Ast.Manip.exp_iter_var (fun v ->
+    match v with
+    | State.Var.ReadVar _ -> found_symread := true; warn "State contains symbolic read variable:\n %t" (Pp.top State.Var.pp v)
+    | _ -> ()
+  ));
+  if !found_symread then
+    warn "State:\n%t" (Pp.top State.pp st);
+
+  if not (State.is_possible st) then
+    { all_fail=true; errors=[] }
+  else match l with
+  | Block_lib.End _ -> let result = (
+      let pc_exp = State.get_reg_exp st pc in
+      let pc_addr = try
+        Some (State.Exp.expect_sym_address pc_exp)
+      with
+        _ -> None
+      in
+      let ret_exp = match pc_addr with
+      | Some pc_addr ->
+        if pc_addr = Elf.Address.{ section="UND.abort"; offset=0 } then
+          Result.error {
+            msg=Printf.sprintf "abort called from %t" (Pp.tos Elf.Address.pp st.last_pc);
+            asserts=st.asserts;
+          }
+        else if pc_addr <> Elf.Address.{ section="UND.exit"; offset=0 } then
+          Result.error {
+            msg=Printf.sprintf "finished at weird address %t" (Pp.tos Elf.Address.pp pc_addr);
+            asserts=st.asserts;
+          }
+        else
+          Result.ok (State.get_reg_exp st ext)
+      | None ->
+        Result.ok (State.get_reg_exp st ret) (* Symbolic pc = returned from main *)
+      in
+      Result.bind ret_exp @@ fun ret_exp ->
+      let ret_val = ret_exp |> Exp.ConcreteEval.eval |> Exp.Value.expect_bv |> BitVec.to_int in
+      if ret_val <> 0 then
+        Result.error {
+          msg=Printf.sprintf "non-zero return code %d" ret_val;
+          asserts=st.asserts
+        }
+      else
+        Result.ok ()
+    ) in
+    node_result_of_result result
+  | _ ->
+    let results = List.map (process_tree ~pc ~ret ~ext) node.rest in
+    let all_errors = List.bind results (fun x -> x.errors) in
+    if List.for_all (fun x -> x.all_fail) results then {
+      all_fail=true;
+      errors=List.map (fun x -> {x with asserts=st.asserts}) all_errors;
+    }
+    else {
+      all_fail=false;
+      errors=all_errors;
+    }
+
 let test return_register exit_register name =
   let tree = Func.get_state_tree ~elf:name ~name:"main" ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:false ()
     ~breakpoints:["UND.abort"; "UND.exit"]
@@ -13,41 +82,13 @@ let test return_register exit_register name =
   let pc = Arch.pc () in
   let ret = State.Reg.of_string return_register in
   let ext = State.Reg.of_string exit_register in
-  State.Tree.iter (fun l st ->
-    let found_symread = ref false in
-    st.read_vars |> Vec.iter Fun.(State.Tval.exp %> Ast.Manip.exp_iter_var (fun v ->
-      match v with
-      | State.Var.ReadVar _ -> found_symread := true; warn "State contains symbolic read variable:\n %t" (Pp.top State.Var.pp v)
-      | _ -> ()
-    ));
-    if !found_symread then
-      warn "State:\n%t" (Pp.top State.pp st);
-    if State.is_possible st then
-      match l with
-      | Block_lib.End _ -> (
-          let pc_exp = State.get_reg_exp st pc in
-          let ret_exp = match (try
-              Some (State.Exp.expect_sym_address pc_exp)
-            with
-              _ -> None
-            ) with
-              | Some pc_addr ->
-                if pc_addr = Elf.Address.{ section="UND.abort"; offset=0 } then
-                  fail "abort called from %t" (Pp.top Elf.Address.pp st.last_pc)
-                else if pc_addr <> Elf.Address.{ section="UND.exit"; offset=0 } then
-                  fail "finished at weird address %t" (Pp.top Elf.Address.pp pc_addr)
-                else
-                  State.get_reg_exp st ext
-              | None ->
-                State.get_reg_exp st ret (* Symbolic pc = returned from main *)
-          in
-          let ret_val = ret_exp |> Exp.ConcreteEval.eval |> Exp.Value.expect_bv |> BitVec.to_int in
-          if ret_val <> 0 then
-            fail "non-zero return code %d" ret_val;
-      )
-      | _ -> ()
-  ) tree;
-  base "Success"
+  let results = process_tree ~pc ~ret ~ext tree in
+  if List.is_empty results.errors then
+    base "Success"
+  else
+    fail "Some paths fail: %t" Pp.(
+      top (list (fun (e:err) -> !^(e.msg) ^^ !^" when " ^^ list State.Exp.pp e.asserts)) results.errors
+    )
 
 let elf =
   let doc = "ELF file from which to pull the code" in
diff --git a/src/state/simplify.ml b/src/state/simplify.ml
index 3fee6e92..14088110 100644
--- a/src/state/simplify.ml
+++ b/src/state/simplify.ml
@@ -90,11 +90,18 @@ let ctxfull state =
       (fun e ->
         declare e;
         match Z3St.check_both serv e with
-        | Some true -> None
+        | Some true ->
+            debug "%t is redundant" (Pp.top Exp.pp e);
+            None
         | Some false ->
             found_false := true;
+            debug "%t is impossible" (Pp.top Exp.pp e);
             None
-        | None -> Some e)
+        | None -> 
+            debug "%t is possible" (Pp.top Exp.pp e);
+            Z3St.send_assert serv e;
+            Some e
+        )
       state.asserts
   in
   (* If state is impossible then it has a single assertion: false *)

From 0cf6b06ff2ab5f52af4bfcc2f5227805f7b26ec9 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 14 Apr 2025 20:41:48 +0100
Subject: [PATCH 074/116] Fix provenance with section fragments

---
 src/state/base.ml | 50 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 34 insertions(+), 16 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index d6e93053..18c52de8 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -320,24 +320,26 @@ module Mem = struct
     mutable main : Fragment.t;
     frags : (Exp.t * Fragment.t) Vec.t;
     sections : (string, provenance) Hashtbl.t; (* mapping sections to their fragments *)
+    mutable allow_main : bool; (* HACK to prvent incorrectly assuming Main provenance when using section fragments  *)
   }
 
   (** Get the main fragment of memory *)
-  let get_main { main; frags = _; sections = _ } = main
+  let get_main { main; _ } = main
 
   (** Empty memory, every address is unbound *)
-  let empty () = { main = Fragment.empty; frags = Vec.empty (); sections = Hashtbl.create 10 }
+  let empty () = { main = Fragment.empty; frags = Vec.empty (); sections = Hashtbl.create 10; allow_main = true }
 
   (** Build a new memory from the old one by keeping the old one as a base *)
   let from mem =
     { 
       main = Fragment.from mem.main;
       frags = Vec.map (Pair.map Fun.id Fragment.from) mem.frags;
-      sections = Hashtbl.copy mem.sections; 
+      sections = Hashtbl.copy mem.sections;
+      allow_main = mem.allow_main;
     }
 
   (** Copy the memory so that it can be mutated separately *)
-  let copy mem = { main = mem.main; frags = Vec.copy mem.frags; sections = Hashtbl.copy mem.sections }
+  let copy mem = { main = mem.main; frags = Vec.copy mem.frags; sections = Hashtbl.copy mem.sections; allow_main = mem.allow_main }
 
   (** Add a new fragment with the specified base *)
   let new_frag mem base =
@@ -559,11 +561,13 @@ let init_sections ~addr_size state =
   let state = copy_if_locked state in
   let _ = Option.(
     let+ elf = state.elf in
+    state.mem.allow_main <- false;
     push_section_constraints ~addr_size state elf.sections;
+    List.iter (fun (x:Elf.File.section) -> Mem.create_section_frag ~addr_size state.mem x.name |> ignore) elf.sections;
     Elf.SymTable.iter elf.symbols @@ fun sym ->
       let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
       if sym.typ = Elf.Symbol.OBJECT then
-        let provenance = Mem.create_section_frag ~addr_size state.mem sym.addr.section in
+        let provenance = Mem.get_section_provenance state.mem sym.addr.section in
         Seq.iota_step_up ~step:len ~endi:sym.size
         |> Seq.iter (fun off ->
           let data = Elf.Symbol.sub sym off len in
@@ -667,15 +671,18 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
         )
     )
 
-let read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+let rec read ~provenance ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
   assert (not @@ is_locked s);
-  let var = make_read ?ctyp s size in
-  let exp = Mem.read s.mem ~provenance ~var ~addr ~size in
-  let exp = if provenance = Main && exp = None then read_from_rodata ~addr ~size s else exp in
-  Option.iter (set_read s (Var.expect_readvar var)) exp;
-  Option.value exp ~default:(Exp.of_var var)
-
-let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
+  if provenance = Ctype.Main && not s.mem.allow_main then
+    read_noprov ?ctyp s ~addr ~size
+  else
+    let var = make_read ?ctyp s size in
+    let exp = Mem.read s.mem ~provenance ~var ~addr ~size in
+    let exp = if exp = None then read_from_rodata ~addr ~size s else exp in
+    Option.iter (set_read s (Var.expect_readvar var)) exp;
+    Option.value exp ~default:(Exp.of_var var)
+
+and read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
   debug "Addr: %t" Pp.(top Exp.pp addr);
   let elf_addr = eval_address s addr in
   debug "Address: %t" Pp.(top (optional Elf.Address.pp) elf_addr);
@@ -684,16 +691,23 @@ let read_noprov ?ctyp (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t =
       let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
       let addr = Exp.of_address ~size:addr_size elf_addr in
       let provenance = Mem.get_section_provenance s.mem elf_addr.section in
+      if provenance = Ctype.Main && not s.mem.allow_main then
+        Raise.fail "Main fragment should not be used here";
       read ~provenance ?ctyp s ~addr ~size
   | None when Vec.length s.mem.frags = 0 ->
+      if not s.mem.allow_main then
+        Raise.fail "Main fragment should not be used here";
       read ~provenance:Ctype.Main ?ctyp s ~addr ~size
   | None -> Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
 
-let write ~provenance (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) : unit =
+let rec write ~provenance (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) : unit =
   assert (not @@ is_locked s);
-  Mem.write ~provenance s.mem ~addr ~size ~exp:value
+  if provenance = Ctype.Main && not s.mem.allow_main then
+    write_noprov s ~addr ~size value
+  else
+    Mem.write ~provenance s.mem ~addr ~size ~exp:value
 
-let write_noprov (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) : unit =
+and write_noprov (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) : unit =
   let elf_addr = eval_address s addr in
   debug "Address: %t" Pp.(top (optional Elf.Address.pp) elf_addr);
   match elf_addr with
@@ -701,8 +715,12 @@ let write_noprov (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) (value : Exp.t) :
       let addr_size = addr |> Typed.get_type |> Typed.expect_bv in
       let addr = Exp.of_address ~size:addr_size elf_addr in
       let provenance = Mem.get_section_provenance s.mem elf_addr.section in
+      if provenance = Ctype.Main && not s.mem.allow_main then
+        Raise.fail "Main fragment should not be used here";
       write ~provenance s ~addr ~size value
   | None when Vec.length s.mem.frags = 0 ->
+      if not s.mem.allow_main then
+        Raise.fail "Main fragment should not be used here";
       write ~provenance:Ctype.Main s ~addr ~size value
   | None -> Raise.fail "Trying to access %t in state %d: No provenance info" Pp.(tos Exp.pp addr) s.id
 

From 1f25a8fcdda7a1b930193e72587e925a4c0508f3 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 24 Apr 2025 13:20:54 +0100
Subject: [PATCH 075/116] Make fbreg locations work

---
 src/dw/var.ml      | 15 +++++++++++--
 src/run/relProg.ml | 52 ++++++++++++++++++++++++++++++++--------------
 2 files changed, 49 insertions(+), 18 deletions(-)

diff --git a/src/dw/var.ml b/src/dw/var.ml
index b6010848..a6a28c6c 100644
--- a/src/dw/var.ml
+++ b/src/dw/var.ml
@@ -48,7 +48,13 @@
 type range = Addr.t * Addr.t option
 
 (** Type of a DWARF variable *)
-type t = { name : string; param : bool; ctype : Ctype.t; locs : (range * Loc.t) list }
+type t = {
+  name : string;
+  param : bool;
+  ctype : Ctype.t;
+  locs : (range * Loc.t) list;
+  locs_frame_base : (range * Loc.t) list;
+}
 
 (** Type of a DWARF variable in linksem *)
 type linksem_t = Dwarf.sdt_variable_or_formal_parameter
@@ -78,7 +84,12 @@ let of_linksem (elf : Elf.File.t) (env : Ctype.env) (lvar : linksem_t) : t =
     |> List.map (fun (a, b, l) -> ((Addr.of_sym a, end_addr_of_sym b), Loc.of_linksem elf l))
     |> loc_merge
   in
-  { name; param; ctype; locs }
+  let locs_frame_base =
+    lvar.svfp_locations_frame_base |> Option.value ~default:[]
+    |> List.map (fun (a, b, l) -> ((Addr.of_sym a, end_addr_of_sym b), Loc.of_linksem elf l))
+    |> loc_merge
+  in
+  { name; param; ctype; locs; locs_frame_base }
 
 (** Pretty print a variable *)
 let pp_raw v =
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index bb7b2edf..aeca7ac6 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -54,8 +54,8 @@ let read_big ~prov st addr sz =
   |> List.of_seq
   |> Exp.Typed.concat
 
-let pp_eval_loc sz st ~(tenv: Ctype.env) ~(ctype: Ctype.t) (loc: Dw.Loc.t) : PPrint.document =
-  let value = match loc with
+let eval_loc ?frame_value sz st (loc: Dw.Loc.t) : State.Exp.t option =
+  match loc with
   | Register reg -> Some (State.get_reg_exp st reg)
   | RegisterOffset (reg, off) ->
       let r = State.get_reg st reg in
@@ -66,14 +66,40 @@ let pp_eval_loc sz st ~(tenv: Ctype.env) ~(ctype: Ctype.t) (loc: Dw.Loc.t) : PPr
         | _ -> None
       ) in
       Some (read_big ~prov st Exp.Typed.(r.exp + bits_int ~size:64 off) sz)
-  | StackFrame _off -> 
-      None
+  | StackFrame off -> 
+    (* This is a bit hacky, should instead extract the provenance from frame_value *)
+    let stack_provenance = Option.bind (State.get_reg st (Arch.sp())).ctyp (fun ctype ->
+      match ctype.unqualified with
+      | Ptr { provenance; _ } -> Some provenance
+      | _ -> None
+    ) in
+
+    let open Option in
+    let+ frame_value = frame_value in
+    debug "Reading from %t" Pp.(top State.Exp.pp Exp.Typed.(frame_value + bits_int ~size:64 off));
+    read_big ~prov:stack_provenance st Exp.Typed.(frame_value + bits_int ~size:64 off) sz
   | Global symoff -> 
       let addr = Elf.SymTable.to_addr_offset symoff in
       let addr = State.Exp.of_address ~size:Arch.address_size addr in
       Some (read_big ~prov:None st addr sz)
   | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
-  | Dwarf _ops -> None in
+  | Dwarf _ops -> None
+
+let eval_loc_from_list ?frame_value sz st pc locs=
+  let open Option in
+  let+ loc = List.find_map (fun ((lo,hi), loc) -> (
+    let open Elf.Address in
+    let* hi = hi in
+    let* over = lo <= pc in
+    let* under = pc < hi in
+    if over && under then
+      Some loc
+    else
+      None
+  )) locs in
+  eval_loc ?frame_value sz st loc
+
+let pp_variable_value  ~(tenv: Ctype.env) ~(ctype: Ctype.t) value =
   let pp = fun value ->
     match Exp.ConcreteEval.eval_if_concrete value with
     | Some(value) -> Exp.Value.pp value
@@ -88,18 +114,12 @@ let printvars ~st ~(dwarf: Dw.t) pc =
   let pv vars =
     Seq.iter (fun (v: Dw.Var.t) -> 
       let sz = Ctype.sizeof v.ctype in
-      match List.find_map (fun ((lo,hi), loc) -> Option.(
-        let open Elf.Address in
-        let* hi = hi in
-        let* over = lo <= pc in
-        let* under = pc < hi in
-        if over && under then
-          Some loc
-        else
-          None
-      )) v.locs with
+      let frame_value = eval_loc_from_list sz st pc v.locs_frame_base |> Option.join in
+      debug "Frame value %t" Pp.(top (optional State.Exp.pp) frame_value);
+      let value = eval_loc_from_list ?frame_value sz st pc v.locs in
+      match value with
       | None -> ()
-      | Some loc -> out := !out ^ Printf.sprintf "%s = %t\n" v.name Pp.(tos (pp_eval_loc sz st ~ctype:v.ctype ~tenv:dwarf.tenv) loc);
+      | Some var_val -> out := !out ^ Printf.sprintf "%s = %t\n" v.name Pp.(tos (pp_variable_value ~ctype:v.ctype ~tenv:dwarf.tenv) var_val);
     )
     vars
   in

From 0ff8cc9510fc77ef1b9ab65496d4b31b5955b045 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 27 Apr 2025 11:44:58 +0100
Subject: [PATCH 076/116] Fix read rodata

---
 src/state/base.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 18c52de8..ac324ec0 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -661,7 +661,7 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
         let int_addr = sym_addr.offset in
         let open Option in
         let* rodata = Elf.File.SMap.find_opt sym_addr.section elf.rodata in
-        if rodata.addr <= int_addr && int_addr + size < rodata.addr + rodata.size * 8 then
+        if rodata.addr <= int_addr && int_addr + size <= rodata.addr + rodata.size * 8 then
           let bv = BytesSeq.getbvle ~size rodata.data (int_addr - rodata.addr) in
           (* Assume little endian here *)
           Some (Typed.bits bv)

From 38f9e1146b9a416a2a4735f95b0d989a0e64ed09 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 27 Apr 2025 11:45:45 +0100
Subject: [PATCH 077/116] Fix printing execution

---
 src/run/relProg.ml | 40 +++++++++++++++++++++-------------------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index aeca7ac6..5526eb21 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -165,25 +165,27 @@ let run_prog elfname name objdump_d branchtables =
   let get_footprint pc =
     Runner.get_normal_opt runner pc |> Option.fold ~none:[] ~some:Trace.Instr.footprint
   in *)
-  State.Tree.iter
-    (fun a st ->
-      let last_pc = st.last_pc in
-      (match a with
-      | Block_lib.Start -> ()
-      | Block_lib.BranchAt pc -> 
-          if Elf.Address.(last_pc + 4 <> pc) then
-            Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
-          print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
-          print_string (print_analyse_instruction pc);
-          print_endline "BRANCH!";
-      | Block_lib.NormalAt pc ->
-          if Elf.Address.(last_pc + 4 <> pc) then
-            Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
-          print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
-          print_string (print_analyse_instruction pc);
-      | Block_lib.End _ -> ());
-    )
-    tree;
+  let rec iter (f:Block_lib.label State.Tree.t) =
+    let st = f.state in
+    let last_pc = st.last_pc in
+    (match f.data with
+    | Block_lib.Start -> ()
+    | Block_lib.BranchAt pc | Block_lib.NormalAt pc -> 
+        if Elf.Address.(last_pc + 4 <> pc) then
+          Printf.printf "\nJUMP from %t:\n\n" Pp.(top Elf.Address.pp last_pc);
+        print_string @@ Analyse.Pp.css Analyse.Types.Html Render_vars @@ printvars ~st ~dwarf pc;
+        print_string (print_analyse_instruction pc);
+    | Block_lib.End _ -> 
+        print_string "END";
+      );
+    let succ = List.filter (fun (s:Block_lib.label State.Tree.t) ->
+      State.is_possible s.state
+    ) f.rest in
+    if List.length succ > 1 then
+      print_string "BRANCH!";
+    List.iter iter succ
+  in
+  iter tree;
   match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
   | Error _ -> ()
   | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines

From 19343af0ac199093efc34c49d4f4260d2a0ccf6a Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 30 Apr 2025 21:16:03 +0100
Subject: [PATCH 078/116] Nicer visualization

---
 src/run/relProg.ml | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 5526eb21..a7f8d109 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -16,22 +16,22 @@ let rec pp_array pp sz dims value =
       |> List.of_seq
       |> Pp.list (pp_array pp sz dims) 
 
-let pp_typed ~(tenv: Ctype.env) ~(ctype: Ctype.t) ~pp (value: State.Exp.t) =
+let pp_typed ~(tenv: Ctype.env) ~(ctype: Ctype.t) ~(pp : ?hex:bool -> _ -> _) (value: State.Exp.t) =
   match ctype.unqualified with
   | Machine _ -> pp value
   | Cint _ -> pp value
   | Cbool -> pp value
-  | Ptr _ -> pp value
+  | Ptr _ -> pp ~hex:true value
   | Struct { id; _ } ->
       let s = IdMap.geti tenv.structs id in
       Pp.(
         Ctype.FieldMap.to_seq s.layout
         |> Seq.map (fun (offset, (field:Ctype.field)) -> (
-          opt string field.fname,
+          Option.value ~default:"?" field.fname,
           pp (Exp.Typed.extract ~first:(8*offset) ~last:(8*(offset + field.size)-1) value)
         ))
         |> List.of_seq
-        |> mapping s.name
+        |> record s.name
       )
   | Array { dims; _ } ->
       let sz = Ctype.sizeof ctype in
@@ -100,8 +100,9 @@ let eval_loc_from_list ?frame_value sz st pc locs=
   eval_loc ?frame_value sz st loc
 
 let pp_variable_value  ~(tenv: Ctype.env) ~(ctype: Ctype.t) value =
-  let pp = fun value ->
+  let pp ?(hex=false) = fun value ->
     match Exp.ConcreteEval.eval_if_concrete value with
+    | Some(Exp.Value.Bv bv) when not hex -> Pp.int @@ BitVec.to_int bv
     | Some(value) -> Exp.Value.pp value
     | None -> State.Exp.pp value
   in

From e66ab9ca456260dfb1b586b1c640661ef9b2ad2f Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 1 May 2025 23:34:17 +0100
Subject: [PATCH 079/116] Allow relocations in rodata and fix endianness
 problems

---
 src/elf/file.ml               | 23 +++++++++++++---------
 src/elf/linksemRelocatable.ml | 18 +++++++++--------
 src/elf/segment.ml            |  4 ++--
 src/state/base.ml             | 37 ++++++++++++++++++++++++-----------
 src/trace/run.ml              |  2 ++
 5 files changed, 54 insertions(+), 30 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index 3dcc5291..ecac2613 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -152,23 +152,28 @@ let of_file (filename : string) =
   }) elf64_file.elf64_file_interpreted_sections
   in
   let rodata =
-    SMap.of_list @@ List.filter_map Option.(fun section ->
-      let+ sname = if String.starts_with ~prefix:".rodata" section.name then
-        Some section.name
+    SMap.of_list @@ List.filter_map Option.(fun (section:Elf_interpreted_section.elf64_interpreted_section) ->
+      let+ sname = if String.starts_with ~prefix:".rodata" section.elf64_section_name_as_string then
+        Some section.elf64_section_name_as_string
       else
         None
       in
-      let (_, addr, data) =
-        Dwarf.extract_section_body_without_relocations elf_file sname false
+      let data = section.elf64_section_body in
+      Printf.printf "%t" Pp.(top BytesSeq.pp data);
+      let relocations = match LinksemRelocatable.get_relocations_for_section elf64_file sname with
+      | Error.Fail s -> elferror "LinksemRelocatable: get_relocations_for_section: %s" s
+      | Error.Success x -> Relocations.of_linksem x
+      in 
+      (* let (_, addr, data) =
+        Dwarf.extract_section_body elf_file Abi_aarch64_symbolic_relocation.aarch64_data_relocation_interpreter sname false
         (* `false' argument is for returning an empty byte-sequence if
           section is not found, instead of throwing an exception *)
-      in
-      Printf.printf "%t" Pp.(top Sym.pp addr);
+      in *)
       (
         sname,
         Segment.
         {
-          data;
+          data = (data, relocations);
           addr = 0; (* Meaningless for relocatable files *)
           size = BytesSeq.length data;
           read = true;
@@ -176,7 +181,7 @@ let of_file (filename : string) =
           execute = false;
         }
       )
-    ) sections
+    ) elf64_file.elf64_file_interpreted_sections
   in
   info "ELF file %s has been loaded" filename;
   { filename; symbols; entry; machine; linksem = elf_file; rodata; sections }
diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
index 99998fb7..eb0900d8 100644
--- a/src/elf/linksemRelocatable.ml
+++ b/src/elf/linksemRelocatable.ml
@@ -19,21 +19,23 @@ type global_symbol_init_info = symbol list
 open Elf_symbol_table
 open Elf_interpreted_section
 
+let get_relocations_for_section (f:Elf_file.elf64_file) section =
+  let machine = f.elf64_file_header.elf64_machine in
+  if machine = Elf_header.elf_ma_aarch64 then
+    Error.bind
+      (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.aarch64_relocation_interpreter section)
+      @@ fun relocs -> Error.return (AArch64 relocs)
+  else
+    Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
+
 let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_init_info Error.error =
   let secs = f.elf64_file_interpreted_sections in
-  let machine = f.elf64_file_header.elf64_machine in
   Error.bind (Elf_file.get_elf64_file_symbol_table f) @@ fun (symtab, strtab) ->
     let rel_cache = ref SMap.empty in
     let get_relocs section =
       match SMap.find_opt section !rel_cache with
       | Some rels -> rels
-      | None ->
-        if machine = Elf_header.elf_ma_aarch64 then
-          Error.bind
-            (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.aarch64_relocation_interpreter section)
-            @@ fun relocs -> Error.return (AArch64 relocs)
-        else
-          Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
+      | None -> get_relocations_for_section f section
     in
     List.filter_map (
       fun entry ->
diff --git a/src/elf/segment.ml b/src/elf/segment.ml
index faacf802..51b82009 100644
--- a/src/elf/segment.ml
+++ b/src/elf/segment.ml
@@ -51,7 +51,7 @@
 
 (** The type of a segment *)
 type t = {
-  data : BytesSeq.t;
+  data : BytesSeq.t * Relocations.t;
   addr : int;  (** The actual start address of the BytesSeq *)
   size : int;  (** redundant with {!Utils.BytesSeq.length} data *)
   read : bool;
@@ -66,7 +66,7 @@ let of_linksem (lseg : Elf_interpreted_segment.elf64_interpreted_segment) : t =
   BytesSeq.blit lseg.elf64_segment_body 0 bytes 0 (Z.to_int lseg.elf64_segment_size);
   let (read, write, execute) = lseg.elf64_segment_flags in
   {
-    data = BytesSeq.of_bytes bytes;
+    data = BytesSeq.of_bytes bytes, Relocations.IMap.empty;
     addr = Z.to_int lseg.elf64_segment_base;
     size;
     read;
diff --git a/src/state/base.ml b/src/state/base.ml
index ac324ec0..d1272de3 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -294,10 +294,12 @@ module Relocation = struct
       else
         []
       in
+      let v, a =
       (
-        Typed.concat (before @ relocation.value :: after),
+        Typed.concat (after @ relocation.value :: before),
         relocation.asserts @ asserts
-      )
+      ) in
+      v,a
     ) data.relocations (exp, [])
 end
 
@@ -647,24 +649,37 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
   | None -> None
   | Some elf -> (
       Option.bind (eval_address s addr) @@ fun sym_addr ->
-      let size = size |> Ast.Size.to_bits in
+      let size = size |> Ast.Size.to_bytes in
       try
         let (sym, offset) = Elf.SymTable.of_addr_with_offset elf.symbols sym_addr in
         if sym.writable then None
         else (
-          (* Assume little endian here *)
-          assert (Relocation.IMap.is_empty sym.data.relocations);
-          let bv = BytesSeq.getbvle ~size sym.data.data offset in (* TODO relocations *)
-          Some (Typed.bits bv)
+          let data = Elf.Symbol.sub sym offset size in
+          let value, asserts = Relocation.exp_of_data data in
+          
+          if not @@ List.is_empty asserts then
+            warn "Relocaiton assserts in .rodata ignored: %t" Pp.(top (list Exp.pp) asserts);
+
+          Some value
         )
       with Not_found ->
         let int_addr = sym_addr.offset in
         let open Option in
         let* rodata = Elf.File.SMap.find_opt sym_addr.section elf.rodata in
-        if rodata.addr <= int_addr && int_addr + size <= rodata.addr + rodata.size * 8 then
-          let bv = BytesSeq.getbvle ~size rodata.data (int_addr - rodata.addr) in
-          (* Assume little endian here *)
-          Some (Typed.bits bv)
+        if rodata.addr <= int_addr && int_addr + size <= rodata.addr + rodata.size then
+          let data, relocations = rodata.data in
+          let data = BytesSeq.sub data (int_addr - rodata.addr) size in
+          base "Addr offset: %d, size: %d" int_addr size;
+          base "All relocs: %t" (Pp.top Elf.Relocations.pp relocations);
+          let relocations = Elf.Relocations.sub relocations (int_addr - rodata.addr) size in
+          base "Sub relocs: %t" (Pp.top Elf.Relocations.pp relocations);
+          let value, asserts = Relocation.exp_of_data {data; relocations} in
+          base "Value: %t" (Pp.top Exp.pp value);
+          
+          if not @@ List.is_empty asserts then
+            warn "Relocaiton assserts in .rodata ignored: %t" Pp.(top (list Exp.pp) asserts);
+
+          Some value
         else (
           warn "Failed to find symbol or rodata at %t" (Pp.top Elf.Address.pp sym_addr);
           None
diff --git a/src/trace/run.ml b/src/trace/run.ml
index b0250aae..5298484f 100644
--- a/src/trace/run.ml
+++ b/src/trace/run.ml
@@ -98,6 +98,7 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
         | None ->
             State.read_noprov ctxt.state ~addr:naddr ~size |> State.Tval.of_exp
       in
+      debug "read value: %t" Pp.(top State.Tval.pp tval);
       HashVector.set ctxt.mem_reads value tval
   | WriteMem { addr; value; size } -> (
       let naddr = expand_simplify ~ctxt addr in
@@ -109,6 +110,7 @@ let event_mut ~(ctxt : ctxt) (event : Base.event) =
           let ptrtype = Typer.expr ~ctxt addr in
           debug "Typed write mem with ptr:%t" (Pp.top (Pp.opt Ctype.pp) ptrtype);
           let value = expand_tval ~ctxt value in
+          debug "written value: %t" Pp.(top State.Tval.pp value);
           Typer.write ~dwarf ctxt.state ?ptrtype ~addr:naddr ~size value
       | None ->
           let value = expand_simplify ~ctxt value in

From 0f9393ab4a535e6128151d8cfb0083b8eac94978 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 1 May 2025 23:51:09 +0100
Subject: [PATCH 080/116] Remove print

---
 src/elf/file.ml   | 1 -
 src/state/base.ml | 4 ----
 2 files changed, 5 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index ecac2613..91bef6fc 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -159,7 +159,6 @@ let of_file (filename : string) =
         None
       in
       let data = section.elf64_section_body in
-      Printf.printf "%t" Pp.(top BytesSeq.pp data);
       let relocations = match LinksemRelocatable.get_relocations_for_section elf64_file sname with
       | Error.Fail s -> elferror "LinksemRelocatable: get_relocations_for_section: %s" s
       | Error.Success x -> Relocations.of_linksem x
diff --git a/src/state/base.ml b/src/state/base.ml
index d1272de3..bec126eb 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -669,12 +669,8 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
         if rodata.addr <= int_addr && int_addr + size <= rodata.addr + rodata.size then
           let data, relocations = rodata.data in
           let data = BytesSeq.sub data (int_addr - rodata.addr) size in
-          base "Addr offset: %d, size: %d" int_addr size;
-          base "All relocs: %t" (Pp.top Elf.Relocations.pp relocations);
           let relocations = Elf.Relocations.sub relocations (int_addr - rodata.addr) size in
-          base "Sub relocs: %t" (Pp.top Elf.Relocations.pp relocations);
           let value, asserts = Relocation.exp_of_data {data; relocations} in
-          base "Value: %t" (Pp.top Exp.pp value);
           
           if not @@ List.is_empty asserts then
             warn "Relocaiton assserts in .rodata ignored: %t" Pp.(top (list Exp.pp) asserts);

From 6524a9dd64f1deb62b4aa166ae27ab40ce5c3ae2 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 2 May 2025 00:01:06 +0100
Subject: [PATCH 081/116] Fix debug loc parsing

---
 src/dw/loc.ml      | 13 ++++++++-----
 src/run/relProg.ml |  6 +++++-
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/dw/loc.ml b/src/dw/loc.ml
index 3ead2a51..a63fcc53 100644
--- a/src/dw/loc.ml
+++ b/src/dw/loc.ml
@@ -72,7 +72,7 @@ type t =
   | RegisterOffset of State.Reg.t * int  (** At register + offset address *)
   | StackFrame of int  (** On the stackFrame with offset *)
   | Global of Elf.SymTable.sym_offset  (** Global variable with an offset *)
-  | Const of Z.t
+  | Const of Sym.t
   | Dwarf of dwop list  (** Uninterpreted dwarf location *)
 
 (** The type of a location in linksem format *)
@@ -125,12 +125,12 @@ let of_linksem ?(amap = Arch.dwarf_reg_map ()) (elf : Elf.File.t) : linksem_t ->
       let addr = Addr.of_sym @@ sym_of_oav arg in
       try Global (Elf.SymTable.of_addr_with_offset elf.symbols @@ addr)
       with Not_found ->
-        warn "Symbol at 0x%x not found in Loc.of_linksem" (int_of_oav arg);
+        warn "Symbol at %t not found in Loc.of_linksem" (Pp.top Sym.pp (sym_of_oav arg));
         Dwarf ops
     )
   (* Other *)
   | [{ op_semantics = OpSem_lit; op_argument_values = [arg]; _ }; { op_semantics = OpSem_stack_value; _ }] ->
-      let value = Sym.to_z @@ sym_of_oav arg in 
+      let value = sym_of_oav arg in 
       Const value
   | ops -> Dwarf ops
 
@@ -140,7 +140,7 @@ let to_string = function
   | RegisterOffset (reg, off) -> Printf.sprintf "[%s+%x]" (State.Reg.to_string reg) off
   | StackFrame off -> Printf.sprintf "[frame+%x]" off
   | Global symoff -> Elf.SymTable.string_of_sym_offset symoff
-  | Const x -> Z.to_string x
+  | Const x -> Sym.to_string x
   | Dwarf ops -> Dwarf.pp_operations ops
 
 (** Compare two location. Loc.t is not compatible with polymorphic compare *)
@@ -159,7 +159,10 @@ let compare l1 l2 =
       Pair.compare ~fst:Elf.Symbol.compare (sym1, off1) (sym2, off2)
   | (Global (_, _), _) -> -1
   | (_, Global (_, _)) -> 1
-  | (Const x, Const y) -> Z.compare x y
+  | (Const (Absolute x), Const (Absolute y)) -> Z.compare x y
+  | (Const (Offset(s,x)), Const (Offset(t,y))) -> Pair.compare ~snd:Z.compare (s,x) (t,y)
+  | (Const (Absolute _), Const (Offset _)) -> -1
+  | (Const (Offset _), Const (Absolute _)) -> 1
   | (Const _, _) -> -1
   | (_, Const _) -> 1
   | (Dwarf ops1, Dwarf ops2) -> compare ops1 ops2
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index a7f8d109..20719885 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -82,7 +82,11 @@ let eval_loc ?frame_value sz st (loc: Dw.Loc.t) : State.Exp.t option =
       let addr = Elf.SymTable.to_addr_offset symoff in
       let addr = State.Exp.of_address ~size:Arch.address_size addr in
       Some (read_big ~prov:None st addr sz)
-  | Const x -> Some(x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits)
+  | Const x ->
+      Some (match x with
+      | Absolute x -> x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits
+      | Offset (s, o) -> State.Exp.of_address ~size:(8*sz) Elf.Address.{section=s; offset=Z.to_int o}
+      )
   | Dwarf _ops -> None
 
 let eval_loc_from_list ?frame_value sz st pc locs=

From 2feb3a6c6ace8bb0d1cbf00b9ffda0e9ab83338e Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Fri, 2 May 2025 12:52:28 +0100
Subject: [PATCH 082/116] Add sections non-overlap constraints

---
 src/elf/file.ml        |  15 +++--
 src/run/func.ml        |   4 +-
 src/run/funcRD.ml      |   2 +-
 src/run/relProg.ml     |   2 +-
 src/run/testRelProg.ml |   2 +-
 src/state/base.ml      | 139 ++++++++++++++++++++++++-----------------
 src/state/base.mli     |   4 +-
 7 files changed, 99 insertions(+), 69 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index 91bef6fc..095ad835 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -145,11 +145,16 @@ let of_file (filename : string) =
      - the range of the section is guaranteed to overlap with any symbols
        within it, and so not suitable to be stored in the [RngMap] *)
   let elf_file = Elf_file.ELF_File_64 elf64_file in
-  let sections = List.map (fun (s:Elf_interpreted_section.elf64_interpreted_section) -> {
-    name=s.elf64_section_name_as_string;
-    size=Z.to_int s.elf64_section_size;
-    align=Z.to_int s.elf64_section_align;
-  }) elf64_file.elf64_file_interpreted_sections
+  let sections = List.filter_map (fun (s:Elf_interpreted_section.elf64_interpreted_section) ->
+    if Z.equal Z.zero (Z.logand s.elf64_section_flags Elf_section_header_table.shf_alloc) then
+      None
+    else
+      Some {
+        name=s.elf64_section_name_as_string;
+        size=Z.to_int s.elf64_section_size;
+        align=Z.to_int s.elf64_section_align;
+      }
+  ) elf64_file.elf64_file_interpreted_sections
   in
   let rodata =
     SMap.of_list @@ List.filter_map Option.(fun (section:Elf_interpreted_section.elf64_interpreted_section) ->
diff --git a/src/run/func.ml b/src/run/func.ml
index 4ea1d385..08ac6c2b 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -52,7 +52,7 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic ~addr_size:Arch.address_size) () =
+let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic ~sp:Arch.sp ~addr_size:Arch.address_size) () =
   base "Running %s in %s" name elfname;
   let dwarf = Dw.of_file elfname in
   let elf = dwarf.elf in
@@ -66,7 +66,7 @@ let no_run_prep ~elf:elfname ~name ~entry ?(init = State.init_sections_symbolic
   let abi = Arch.get_abi api in
   Trace.Cache.start @@ Arch.get_isla_config ();
   base "Computing entry state";
-  let start = Init.state () |> State.copy ~elf |> init |> abi.init in
+  let start = Init.state () |> State.copy ~elf |> abi.init |> init in
   if entry then base "Entry state:\n%t" (Pp.topi State.pp start);
   (dwarf, elf, func, start)
 
diff --git a/src/run/funcRD.ml b/src/run/funcRD.ml
index f2d1fffb..052b50b9 100644
--- a/src/run/funcRD.ml
+++ b/src/run/funcRD.ml
@@ -74,7 +74,7 @@ let run_func_rd elfname name objdump_d branchtables breakpoints =
   let abi = Arch.get_abi api in
   Trace.Cache.start @@ Arch.get_isla_config ();
   base "Computing entry state";
-  let start = Init.state () |> State.copy ~elf |> State.init_sections ~addr_size:Arch.address_size |> abi.init in
+  let start = Init.state () |> State.copy ~elf |> abi.init |> State.init_sections ~sp:Arch.sp ~addr_size:Arch.address_size in
   base "Loading %s for Analyse" elfname;
   let analyse_test = Analyse.Elf.parse_elf_file elfname in
   base "Analysing %s for Analyse" elfname;
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 20719885..f4a0f354 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -159,7 +159,7 @@ let run_prog elfname name objdump_d branchtables =
       instr
   in
   base "Start running";
-  let tree = Func.get_state_tree ~elf:elfname ~name ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:true ()
+  let tree = Func.get_state_tree ~elf:elfname ~name ~init:(State.init_sections ~sp:Arch.sp ~addr_size:Arch.address_size) ~every_instruction:true ()
     ~breakpoints:["UND.abort"; "UND.exit"]
   in
   base "Ended running, start pretty printing";
diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
index 3ac67b19..e9f15408 100644
--- a/src/run/testRelProg.ml
+++ b/src/run/testRelProg.ml
@@ -75,7 +75,7 @@ let rec process_tree ~pc ~ret ~ext (node:Block_lib.label State.Tree.t) =
     }
 
 let test return_register exit_register name =
-  let tree = Func.get_state_tree ~elf:name ~name:"main" ~init:(State.init_sections ~addr_size:Arch.address_size) ~every_instruction:false ()
+  let tree = Func.get_state_tree ~elf:name ~name:"main" ~init:(State.init_sections ~sp:Arch.sp ~addr_size:Arch.address_size) ~every_instruction:false ()
     ~breakpoints:["UND.abort"; "UND.exit"]
   in
   debug "%t" (Pp.top (State.Tree.pp_all Block_lib.pp_label) tree);
diff --git a/src/state/base.ml b/src/state/base.ml
index bec126eb..2f4c78ba 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -537,63 +537,6 @@ let set_impossible state =
   assert (not @@ is_locked state);
   state.asserts <- [Typed.false_]
 
-let push_section_constraints ~addr_size state sections =
-  List.iter (fun (s:Elf.File.section) ->
-    let max_section_addr = Int.shift_left 1 addr_size - s.size in
-    let s_exp = (Exp.of_var (Var.Section s.name)) in
-    (* The whole section fits in memory *)
-    push_assert state Typed.(comp Ast.Bvule s_exp (bits_int ~size:64 max_section_addr));
-    (* The load address cannot be 0 *)
-    push_assert state Typed.(not (s_exp = (bits_int ~size:64 0)));
-    if s.align > 1 then
-      let (align_pow, _) = Seq.ints 0
-      |> Seq.drop_while (fun x -> Int.shift_left 1 x < s.align)
-      |> Seq.uncons
-      |> Option.get
-      in
-      if s.align = Int.shift_left 1 align_pow then
-        let last = align_pow - 1 in
-        (* Section address is aligned *)
-        push_assert state Typed.(extract ~first:0 ~last s_exp = zero ~size:align_pow)
-      else
-        warn "Section alignment is not a power of two: %d" s.align;
-  ) sections
-
-let init_sections ~addr_size state =
-  let state = copy_if_locked state in
-  let _ = Option.(
-    let+ elf = state.elf in
-    state.mem.allow_main <- false;
-    push_section_constraints ~addr_size state elf.sections;
-    List.iter (fun (x:Elf.File.section) -> Mem.create_section_frag ~addr_size state.mem x.name |> ignore) elf.sections;
-    Elf.SymTable.iter elf.symbols @@ fun sym ->
-      let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
-      if sym.typ = Elf.Symbol.OBJECT then
-        let provenance = Mem.get_section_provenance state.mem sym.addr.section in
-        Seq.iota_step_up ~step:len ~endi:sym.size
-        |> Seq.iter (fun off ->
-          let data = Elf.Symbol.sub sym off len in
-          let addr = Exp.of_address ~size:addr_size Elf.Address.(sym.addr + off) in
-          let size = Ast.Size.of_bytes len in
-          let (exp, asserts) = Relocation.exp_of_data data in
-          Mem.write ~provenance state.mem ~addr ~size ~exp;
-          List.iter (push_relocation_assert state) asserts;
-        )
-  ) in
-  state
-
-let init_sections_symbolic ~addr_size state =
-  let state = copy_if_locked state in
-  let _ = Option.(
-    let+ elf = state.elf in
-    push_section_constraints ~addr_size state elf.sections;
-    Elf.SymTable.iter elf.symbols @@ fun sym ->
-      if sym.typ = Elf.Symbol.OBJECT then
-        Hashtbl.replace state.mem.sections sym.addr.section Main
-  ) in
-  state
-
-
 let map_mut_exp (f : exp -> exp) s : unit =
   assert (not @@ is_locked s);
   Reg.Map.map_mut_current (Tval.map_exp f) s.regs;
@@ -781,6 +724,88 @@ let set_last_pc state pc =
   assert (not @@ is_locked state);
   state.last_pc <- pc
 
+
+let push_section_constraints ~sp ~addr_size state sections =
+  let sp = sp () in
+  let rec f : Elf.File.section list -> unit = function
+  | [] -> ()
+  | s::rest -> (
+    let max_section_addr = Int.shift_left 1 addr_size - s.size in
+    let s_exp = (Exp.of_var (Var.Section s.name)) in
+    (* The whole section fits in memory *)
+    push_assert state Typed.(comp Ast.Bvule s_exp (bits_int ~size:64 max_section_addr));
+    (* The load address cannot be 0 *)
+    push_assert state Typed.(not (s_exp = (bits_int ~size:64 0)));
+    if s.align > 1 then (
+      let (align_pow, _) = Seq.ints 0
+      |> Seq.drop_while (fun x -> Int.shift_left 1 x < s.align)
+      |> Seq.uncons
+      |> Option.get
+      in
+      if s.align = Int.shift_left 1 align_pow then
+        let last = align_pow - 1 in
+        (* Section address is aligned *)
+        push_assert state Typed.(extract ~first:0 ~last s_exp = zero ~size:align_pow)
+      else
+        warn "Section alignment is not a power of two: %d" s.align
+    );
+    (* Sections don't overlap *)
+    let s_end = Typed.(s_exp + bits_int ~size:64 s.size) in (* we know this doesn't overflow thanks to the other constraints *)
+    List.iter (fun (s2:Elf.File.section) ->
+      let s2_exp = (Exp.of_var (Var.Section s2.name)) in
+      let s2_end = Typed.(s2_exp + bits_int ~size:64 s2.size) in
+      let order1 = Typed.(comp Ast.Bvule s_end s2_exp) in
+      let order2 = Typed.(comp Ast.Bvule s2_end s_exp) in
+      push_assert state Typed.(manyop Or [order1; order2])
+    ) rest;
+    (* Doesn't overlap with stack *)
+    let stack_end = get_reg_exp state sp in
+    let stack_start = Typed.(stack_end - bits_int ~size:64 0x1000) in
+    let order1 = Typed.(comp Ast.Bvule s_end stack_start) in
+    let order2 = Typed.(comp Ast.Bvule stack_end s_exp) in
+    push_assert state Typed.(manyop Or [order1; order2]);
+
+    f rest
+  )
+  in
+  f sections
+
+let init_sections ~sp ~addr_size state =
+  let state = copy_if_locked state in
+  let _ = Option.(
+    let+ elf = state.elf in
+    state.mem.allow_main <- false;
+    push_section_constraints ~sp ~addr_size state elf.sections;
+    List.iter (fun (x:Elf.File.section) -> Mem.create_section_frag ~addr_size state.mem x.name |> ignore) elf.sections;
+    Elf.SymTable.iter elf.symbols @@ fun sym ->
+      let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
+      if sym.typ = Elf.Symbol.OBJECT then
+        let provenance = Mem.get_section_provenance state.mem sym.addr.section in
+        Seq.iota_step_up ~step:len ~endi:sym.size
+        |> Seq.iter (fun off ->
+          let data = Elf.Symbol.sub sym off len in
+          let addr = Exp.of_address ~size:addr_size Elf.Address.(sym.addr + off) in
+          let size = Ast.Size.of_bytes len in
+          let (exp, asserts) = Relocation.exp_of_data data in
+          Mem.write ~provenance state.mem ~addr ~size ~exp;
+          List.iter (push_relocation_assert state) asserts;
+        )
+  ) in
+  lock state;
+  state
+
+let init_sections_symbolic ~sp ~addr_size state =
+  let state = copy_if_locked state in
+  let _ = Option.(
+    let+ elf = state.elf in
+    push_section_constraints ~sp ~addr_size state elf.sections;
+    Elf.SymTable.iter elf.symbols @@ fun sym ->
+      if sym.typ = Elf.Symbol.OBJECT then
+        Hashtbl.replace state.mem.sections sym.addr.section Main
+  ) in
+  lock state;
+  state
+
 let pp s =
   let open Pp in
   record "state"
diff --git a/src/state/base.mli b/src/state/base.mli
index a7275a7e..2d373fd4 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -405,10 +405,10 @@ val copy : ?elf:Elf.File.t -> t -> t
     The returned state is always unlocked *)
 val copy_if_locked : ?elf:Elf.File.t -> t -> t
 
-val init_sections : addr_size:int -> t -> t
+val init_sections : sp:(unit -> Reg.t) -> addr_size:int -> t -> t
 
 (** Assigns all sections with global objects to Main fragment *)
-val init_sections_symbolic : addr_size:int -> t -> t
+val init_sections_symbolic : sp:(unit -> Reg.t) -> addr_size:int -> t -> t
 
 
 (** {1 State convenience manipulation } *)

From cfa543e7ffdd49dac31a95fb07a3474bcc2985fc Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 3 May 2025 13:22:10 +0100
Subject: [PATCH 083/116] debug

---
 src/analyse/Symbols.ml | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/analyse/Symbols.ml b/src/analyse/Symbols.ml
index cc059ae4..6e44279b 100644
--- a/src/analyse/Symbols.ml
+++ b/src/analyse/Symbols.ml
@@ -1,5 +1,9 @@
 (* TODO header *)
 
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
 module SMap = Map.Make (String)
 
 type rels =
@@ -24,12 +28,14 @@ let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_i
     let rel_cache = ref SMap.empty in
     let get_relocs section =
       match SMap.find_opt section !rel_cache with
-      | Some rels -> rels
+      | Some rels -> Error.return rels
       | None ->
         if machine = Elf_header.elf_ma_aarch64 then
           Error.bind
             (Elf_symbolic.extract_elf64_relocations_for_section f Abi_aarch64_symbolic_relocation.aarch64_relocation_interpreter section)
-            @@ fun relocs -> Error.return (AArch64 relocs)
+            @@ fun relocs -> 
+                rel_cache := SMap.add section (AArch64 relocs) !rel_cache;
+                Error.return (AArch64 relocs)
         else
           Error.fail @@ "machine not supported " ^ (Elf_header.string_of_elf_machine_architecture machine)
     in
@@ -65,6 +71,7 @@ let get_elf64_file_global_symbol_init (f: Elf_file.elf64_file) : global_symbol_i
               in
             Error.bind data @@ fun data ->
               Error.bind (String_table.get_string_at name strtab) @@ fun str ->
+              debug "Processed %s\n" str;
               Error.return (str, (typ, size, addr, (data, relocs), bnd))
         ) (List.nth_opt secs shndx)
     ) symtab |> Error.mapM Fun.id
\ No newline at end of file

From e9ca1854d9b3f77220c068cd2e3ca2e54b94003d Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 3 May 2025 15:28:42 +0100
Subject: [PATCH 084/116] More relocation types

---
 src/elf/relocations.ml |  4 +++-
 src/isla/cache.ml      |  9 +++++++--
 src/isla/relocation.ml | 17 +++++++++++++----
 3 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index 66cdc831..9d2d2107 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -81,7 +81,9 @@ let pp_target = Pp.(function
 | AArch64 Abi_aarch64_symbolic_relocation.ADD -> !^"ADD"
 | AArch64 Abi_aarch64_symbolic_relocation.ADRP -> !^"ADRP"
 | AArch64 Abi_aarch64_symbolic_relocation.CALL -> !^"CALL"
-| AArch64 Abi_aarch64_symbolic_relocation.LDST b -> !^"LDST" ^^ int (1 lsl b))
+| AArch64 Abi_aarch64_symbolic_relocation.LDST b -> !^"LDST" ^^ int (1 lsl b)
+| AArch64 Abi_aarch64_symbolic_relocation.CONDBR -> !^"CONDBR"
+| AArch64 Abi_aarch64_symbolic_relocation.B -> !^"B")
 
 let pp_rel rel =
   let hi, lo = rel.mask in
diff --git a/src/isla/cache.ml b/src/isla/cache.ml
index be6f64e8..1cf72492 100644
--- a/src/isla/cache.ml
+++ b/src/isla/cache.ml
@@ -86,7 +86,9 @@ module Opcode (*: Cache.Key *) = struct
   | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP) -> 3
   | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD) -> 4
   | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL) -> 5
-  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST b) -> 6 + b
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST b) -> assert (b < 5); 6 + b
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CONDBR) -> 11
+  | Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.B) -> 12
 
   let reloc_of_id: int -> Relocation.t option = function
   | 0 -> None
@@ -95,7 +97,10 @@ module Opcode (*: Cache.Key *) = struct
   | 3 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP)
   | 4 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD)
   | 5 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL)
-  | x -> Some (Elf.Relocations.AArch64 (Abi_aarch64_symbolic_relocation.LDST (x-6)))
+  | x when x < 11 -> Some (Elf.Relocations.AArch64 (Abi_aarch64_symbolic_relocation.LDST (x-6)))
+  | 11 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CONDBR)
+  | 12 -> Some (Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.B)
+  | x -> fail "Invalid relocation id %d" x
 
   let equal a b =
     match (a, b) with
diff --git a/src/isla/relocation.ml b/src/isla/relocation.ml
index d8e17a5a..c73e231b 100644
--- a/src/isla/relocation.ml
+++ b/src/isla/relocation.ml
@@ -25,20 +25,29 @@ let pp_opcode_with_segments (b, r) =
             BitVec.pp_smt (BitVec.extract 22 31 bits)  
             ^^ !^" x0:12 " ^^
             BitVec.pp_smt (BitVec.extract 0 9 bits)
-        | Abi_aarch64_symbolic_relocation.LDST b -> (* TODO different width loads, alignment *) 
+        | Abi_aarch64_symbolic_relocation.LDST b ->
             BitVec.pp_smt (BitVec.extract (22-b) 31 bits)  
             ^^ !^" x0:" ^^ int (12-b) ^^ !^" " ^^
             BitVec.pp_smt (BitVec.extract 0 9 bits)
         | Abi_aarch64_symbolic_relocation.CALL -> 
             BitVec.pp_smt (BitVec.extract 26 31 bits)  
             ^^ !^" x0:26 "
+        | Abi_aarch64_symbolic_relocation.CONDBR -> 
+            BitVec.pp_smt (BitVec.extract 24 31 bits)  
+            ^^ !^" x0:19 "
+            ^^ BitVec.pp_smt (BitVec.extract 0 4 bits)
+        | Abi_aarch64_symbolic_relocation.B -> 
+            BitVec.pp_smt (BitVec.extract 26 31 bits)  
+            ^^ !^" x0:26 "
       )
 
 (* for interpreting the segments *)
 let segments_of_reloc: t -> segment list = function
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data640 -> fatal "invalid relocation for instructions (Data64)"
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.Data320 -> fatal "invalid relocation for instructions (Data32)"
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP -> ["x0", (0, 1); "x1", (2, 20)] (* or absolute? ["x0", (12, 13); "x1", (14, 32)] *)
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADRP -> ["x0", (0, 1); "x1", (2, 20)]
 | Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.ADD -> ["x0", (0, 11)]
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST b -> ["x0", (0, 11-b)] (* TODO depends on load size *) (* or absolute? ["x0", (2, 11)] *)
-| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL -> ["x0", (0, 25)] (* or absolute? ["x0", (2, 27)] *)
\ No newline at end of file
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.LDST b -> ["x0", (0, 11-b)]
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CALL -> ["x0", (0, 25)]
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.CONDBR -> ["x0", (0, 18)]
+| Elf.Relocations.AArch64 Abi_aarch64_symbolic_relocation.B -> ["x0", (0, 25)]

From d72240d5048d9bebbdd969c52a7fb264b25eb129 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 3 May 2025 16:51:38 +0100
Subject: [PATCH 085/116] new relocation representation in linksem

---
 src/analyse/Symbols.ml        |  2 +-
 src/elf/linksemRelocatable.ml |  2 +-
 src/elf/relocations.ml        | 34 +++++++++++++++-------------------
 3 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/src/analyse/Symbols.ml b/src/analyse/Symbols.ml
index 6e44279b..d555ae9f 100644
--- a/src/analyse/Symbols.ml
+++ b/src/analyse/Symbols.ml
@@ -7,7 +7,7 @@ end)
 module SMap = Map.Make (String)
 
 type rels =
-  | AArch64 of (Z.t, Abi_aarch64_symbolic_relocation.aarch64_relocation_target Elf_symbolic.abstract_relocation) Pmap.map
+  | AArch64 of (Z.t, Abi_aarch64_symbolic_relocation.aarch64_relocation_target Elf_symbolic.universal_relocation) Pmap.map
 
 type sym_data =
 Byte_sequence_wrapper.byte_sequence * rels
diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
index eb0900d8..5f92e2e0 100644
--- a/src/elf/linksemRelocatable.ml
+++ b/src/elf/linksemRelocatable.ml
@@ -5,7 +5,7 @@ module SMap = Map.Make (String)
 type sym_addr = string * Z.t
 
 type rels =
-  | AArch64 of (Z.t, Abi_aarch64_symbolic_relocation.aarch64_relocation_target Elf_symbolic.abstract_relocation) Pmap.map
+  | AArch64 of (Z.t, Abi_aarch64_symbolic_relocation.aarch64_relocation_target Elf_symbolic.universal_relocation) Pmap.map
 
 type sym_data =
 Byte_sequence_wrapper.byte_sequence * rels
diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index 9d2d2107..8021bde4 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -12,8 +12,6 @@ type exp =
 | Const of int
 | BinOp of (exp * binary_operation * exp)
 | UnOp of (unary_operation * exp)
-(* | AssertRange of (exp * int * int) *)
-(* | Mask of (exp * int * int) *)
 
 type assertion =
 | Range of int64 * int64
@@ -30,32 +28,30 @@ type t = rel IMap.t
 
 type linksem_t = LinksemRelocatable.rels
 
-let exp_of_linksem =
+let rel_of_aarch64_linksem Elf_symbolic.{rel_desc_value; rel_desc_checks; rel_desc_mask; rel_desc_target  } =
   let rec value_of_linksem = function
   | Elf_symbolic.Section s -> Section s
   | Elf_symbolic.Const x -> Const (Z.to_int x)
   | Elf_symbolic.BinOp (x, op, y) -> BinOp (value_of_linksem x, op, value_of_linksem y)
   | Elf_symbolic.UnOp (op, x) -> UnOp (op, value_of_linksem x)
-  | Elf_symbolic.AssertRange (_, _, _) -> Raise.fail "AssertRange should not occur in value expression"
-  | Elf_symbolic.AssertAlignment (_, _) -> Raise.fail "AssertAlignment should not occur in value expression"
-  | Elf_symbolic.Mask (_, _, _) -> Raise.fail "AssertRange should not occur in value expression"
-  in function
-  | Elf_symbolic.Mask (e, hi, lo) ->
-      let rec extract_asserts e =
-        match e with
-        | Elf_symbolic.AssertRange (e, min, max) -> let (e, a) = extract_asserts e in e, Range (Z.to_int64 min, Z.to_int64 max) :: a
-        | Elf_symbolic.AssertAlignment (e, bits) -> let (e, a) = extract_asserts e in e, Alignment (Z.to_int bits) :: a
-        | e -> e, []
-        in
-      let e, assertions = extract_asserts e in
-      fun target -> {target; assertions; mask = (Z.to_int hi, Z.to_int lo); value = value_of_linksem e}
-  | _ -> Raise.fail "Expression does not have Mask in top level"
+  in
+  let assertions = List.map (function
+    | Elf_symbolic.Overflow (min, max) -> Range (Z.to_int64 min, Z.to_int64 max)
+    | Elf_symbolic.Alignment (bits) -> Alignment (Z.to_int bits)
+  ) rel_desc_checks in
+  let hi, lo = rel_desc_mask in
+  {
+    target=AArch64 rel_desc_target;
+    assertions;
+    mask = (Z.to_int hi, Z.to_int lo);
+    value = value_of_linksem rel_desc_value
+  }
 
 
 let of_linksem: linksem_t -> t = function
 | LinksemRelocatable.AArch64 relocs ->
-    let add k Elf_symbolic.{ arel_value; arel_target } m =
-      IMap.add (Z.to_int k) (exp_of_linksem arel_value (AArch64 arel_target)) m
+    let add k rel m =
+      IMap.add (Z.to_int k) (rel_of_aarch64_linksem rel) m
     in
     Pmap.fold add relocs IMap.empty
 

From f2f1d24bc3b1cce7923d13d44068f84c7482d76f Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 3 May 2025 16:52:16 +0100
Subject: [PATCH 086/116] rename relocation assertions to checks

---
 src/elf/relocations.ml | 6 +++---
 src/state/base.ml      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index 8021bde4..04117864 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -20,7 +20,7 @@ type assertion =
 type rel = {
   target : target;
   value : exp;
-  assertions: assertion list;
+  checks: assertion list;
   mask : int * int;
 }
 
@@ -35,14 +35,14 @@ let rel_of_aarch64_linksem Elf_symbolic.{rel_desc_value; rel_desc_checks; rel_de
   | Elf_symbolic.BinOp (x, op, y) -> BinOp (value_of_linksem x, op, value_of_linksem y)
   | Elf_symbolic.UnOp (op, x) -> UnOp (op, value_of_linksem x)
   in
-  let assertions = List.map (function
+  let checks = List.map (function
     | Elf_symbolic.Overflow (min, max) -> Range (Z.to_int64 min, Z.to_int64 max)
     | Elf_symbolic.Alignment (bits) -> Alignment (Z.to_int bits)
   ) rel_desc_checks in
   let hi, lo = rel_desc_mask in
   {
     target=AArch64 rel_desc_target;
-    assertions;
+    checks;
     mask = (Z.to_int hi, Z.to_int lo);
     value = value_of_linksem rel_desc_value
   }
diff --git a/src/state/base.ml b/src/state/base.ml
index 2f4c78ba..2657fa7d 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -264,7 +264,7 @@ module Relocation = struct
       | Alignment b ->
         let last = b-1 in
         Typed.(extract ~first:0 ~last value = bits_int ~size:b 0)
-    ) relocation.assertions in
+    ) relocation.checks in
     let (last, first) = relocation.mask in
     let value = Typed.extract ~first ~last value in
     { value; asserts; target = relocation.target }

From cd6e5a8bd46f95111d14faf55cf9e5914e3dda78 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 3 May 2025 16:54:02 +0100
Subject: [PATCH 087/116] rm notes-TODO

---
 notes-TODO | 22 ----------------------
 1 file changed, 22 deletions(-)
 delete mode 100644 notes-TODO

diff --git a/notes-TODO b/notes-TODO
deleted file mode 100644
index 95c382c0..00000000
--- a/notes-TODO
+++ /dev/null
@@ -1,22 +0,0 @@
-Symbolic symbol table
-- value of symbol?? (we don't have segments in relocatable files)
-- can probably keep the same api, but addresses are symbolic
-
-Instruction fetch: is it sound? (rewriting .text)
-
-Z3 finding unique solution
-- Get model -> assert not model -> check now it is unsat
-- Need to extend the protocol probably
-
-SIMREL
-- state = (pc,M) (and registers TODO)
-- (pc,M1) ~ (pc.M2) iff there is MT, such that
-    MT(A1,A2,sz) = T => M1[A1:A1+sz] =T M2[A2:A2+sz]
-    and respects dwarf at pc
-    and maybe some consistency of MT?? e.g. overlaping ranges
-- relation (=T) defined using MT
-    - (=base_type) is equality
-    - (=struct) fieldwise
-    - (=*T):
-        A1 =*T A2 <=> MT(A1,A2,sz(T)) = T
-- Hoare logic (or similar) with MT as variable (only read/write commands)

From 1fa15c3d83bba0e8b3b19a2c86e15a3cfd7ff485 Mon Sep 17 00:00:00 2001
From: maturvo <59334936+maturvo@users.noreply.github.com>
Date: Tue, 13 May 2025 01:48:20 +0100
Subject: [PATCH 088/116] Simrel (#2)

* wip

* wip

* Debug prints

* wip

* Refactor simrel

* Global memory processing

* fixes

* better printing

* cleanup
---
 src/bin/dune                  |   4 +-
 src/bin/readDwarf.ml          |   1 +
 src/relsim/base.ml            | 115 ---------
 src/relsim/dune               |   6 +
 src/relsim/relsim.ml          | 447 ++++++++++++++++++++++++++++++++++
 src/state/base.ml             |   4 +
 src/state/base.mli            |   3 +
 src/state/reg.mli             |   3 +
 src/state/symbolicFragment.ml |   2 +
 src/trace/context.ml          |   5 +-
 src/utils/fullVec.ml          |   5 +
 src/utils/fullVec.mli         |   3 +
 12 files changed, 480 insertions(+), 118 deletions(-)
 delete mode 100644 src/relsim/base.ml
 create mode 100644 src/relsim/dune
 create mode 100644 src/relsim/relsim.ml

diff --git a/src/bin/dune b/src/bin/dune
index fea23d27..02b51b85 100644
--- a/src/bin/dune
+++ b/src/bin/dune
@@ -4,7 +4,7 @@
  (modules main)
  (flags
   (:standard -open Utils))
- (libraries config run utils sig_aarch64 other_cmds))
+ (libraries config run utils sig_aarch64 other_cmds relsim))
 
 (executable
  (name main_riscv64)
@@ -20,4 +20,4 @@
  (flags
   (:standard -open Utils))
  (modules copySourcesCmd copySources dumpDwarf dumpSym readDwarf)
- (libraries run utils config state trace))
+ (libraries run utils config state trace relsim))
diff --git a/src/bin/readDwarf.ml b/src/bin/readDwarf.ml
index 577cac14..9fe1ac33 100644
--- a/src/bin/readDwarf.ml
+++ b/src/bin/readDwarf.ml
@@ -76,6 +76,7 @@ let commands =
     Run.TestRelProg.command;
     CopySourcesCmd.command;
     Z3.Test.command;
+    Relsim.command;
   ]
 
 let _ = Printexc.record_backtrace Config.enable_backtrace
diff --git a/src/relsim/base.ml b/src/relsim/base.ml
deleted file mode 100644
index 43df0a71..00000000
--- a/src/relsim/base.ml
+++ /dev/null
@@ -1,115 +0,0 @@
-(* open Logs.Logger (struct
-  let str = __MODULE__
-end)
-
-module Sums = Exp.Sums
-module Typed = Exp.Typed
-
-module Var = struct
-    (** The type of variables *)
-  type t = Left of State.var | Right of State.var
-
-  let equal a b = match (a,b) with
-  | Left a, Left b -> State.Var.equal a b
-  | Right a, Right b -> State.Var.equal a b
-  | _ -> false
-
-  let pp = function
-  | Left v -> Pp.(!^"L:" ^^ State.Var.pp v)
-  | Right v -> Pp.(!^"R:" ^^ State.Var.pp v)
-
-  (** Get the type of the variable *)
-  let ty = function Left v | Right v -> State.Var.ty v
-
-  let hash = Hashtbl.hash
-
-  let of_string = State.Var.of_string (*TODO*)
-end
-
-module Exp = struct
-  include Exp.Make (Var)
-
-  let left : State.Exp.t -> t = Ast.Manip.exp_map_var (fun v -> Var.Left v)
-
-  let right : State.Exp.t -> t = Ast.Manip.exp_map_var (fun v -> Var.Right v)
-end
-
-type sem_type =
-  | Value of int
-  | Ptr of sem_type
-
-type mem_rel = (State.Exp.t * State.Exp.t * sem_type) list
-
-let rec sem_type_of_ctype Ctype.{unqualified; _} =
-  match unqualified with
-  | Machine b -> Value b
-  | Cint { size; _ } -> Value size
-  | Cbool -> Value 1
-  | Ptr { fragment=Ctype.DynArray t; _ } -> Ptr (sem_type_of_ctype t)
-  | _ -> Raise.todo()
-
-let mem_rel_of_dwarf (dw: (Dw.Var.t * Dw.Var.t) list) : mem_rel =
-  List.map (fun ((v1: Dw.Var.t), (v2: Dw.Var.t)) ->
-    let addr1 = match v1.locs with
-    | [_, Global a] -> 
-      a |> Elf.SymTable.to_addr_offset 
-        |> State.Exp.of_address ~size:Arch.address_size
-        (* |> Ast.Manip.exp_map_var (fun x -> Var.Left x) *)
-    | _ -> Raise.todo()
-    in
-    let addr2 = match v2.locs with
-    | [_, Global a] -> 
-      a |> Elf.SymTable.to_addr_offset 
-        |> State.Exp.of_address ~size:Arch.address_size
-        (* |> Ast.Manip.exp_map_var (fun x -> Var.Right x) *)
-    | _ -> Raise.todo()
-    in
-    let stp = sem_type_of_ctype v1.ctype in
-    (addr1, addr2, stp)
-  ) dw
-
-type rel = mem_rel * Exp.t list
-
-type event = State.Mem.Fragment.Event.t
-type block = State.Mem.Fragment.Block.t
-
-let type_at (mem_rel:mem_rel) (block1:block) (block2:block) =
-  List.find_map (fun (e1,e2,t) ->
-    let (sym1, off1) = Sums.split_concrete e1 in
-    let (sym2, off2) = Sums.split_concrete e2 in
-    if (BitVec.to_int off1 == block1.offset && BitVec.to_int off2 == block2.offset
-        && Option.equal State.Exp.equal sym1 block1.base
-        && Option.equal State.Exp.equal sym2 block2.base)
-    then
-      Some t
-    else
-      None
-  ) mem_rel
-
-module Z3sim = Z3.Make (Var)
-
-let update_rel ((mem, asserts):rel) (e1: event) (e2: event) : rel =
-  (* TODO check sizes *)
-  match e1, e2 with
-  | (Read (block1, v1), Read (block2, v2)) -> (
-      match type_at mem block1 block2 with
-      | Some (Value _) -> mem, Typed.(Exp.of_var (Left v1) = Exp.of_var (Right v2))::asserts
-      | Some (Ptr t) -> (State.Exp.of_var v1, State.Exp.of_var v2, t)::mem, asserts
-      | None -> mem, asserts
-    )
-  | (Write (block1, e1), Write (block2, e2)) -> (
-      (match type_at mem block1 block2 with
-      | Some (Value _) -> Z3
-      | Some (Ptr t) -> Raise.todo() (* Check (e1, e2, t) in mem *)
-      | None -> Raise.fail "simrel failed");
-      mem, asserts
-    )
-  | _ -> Raise.fail "simrel failed"
-
-
-let verify (st1:State.t) (st2:State.t) (dw:(Dw.Var.t * Dw.Var.t) list) =
-  let mem_rel = mem_rel_of_dwarf dw in
-  Raise.todo()
-
-  
- *)
diff --git a/src/relsim/dune b/src/relsim/dune
new file mode 100644
index 00000000..2f6abe26
--- /dev/null
+++ b/src/relsim/dune
@@ -0,0 +1,6 @@
+(library
+ (name relsim)
+ (public_name read-dwarf.relsim)
+ (flags
+  (:standard -open Utils))
+ (libraries utils ast state run z3))
\ No newline at end of file
diff --git a/src/relsim/relsim.ml b/src/relsim/relsim.ml
new file mode 100644
index 00000000..3146a1b4
--- /dev/null
+++ b/src/relsim/relsim.ml
@@ -0,0 +1,447 @@
+open Logs.Logger (struct
+  let str = __MODULE__
+end)
+
+open Cmdliner
+open Config.CommonOpt
+
+module Sums = Exp.Sums
+module Typed = Exp.Typed
+
+module Var = struct
+  type t = Left of State.var | Right of State.var
+
+  let equal a b = match (a,b) with
+  | Left a, Left b -> State.Var.equal a b
+  | Right a, Right b -> State.Var.equal a b
+  | _ -> false
+
+  let pp = function
+  | Left v -> Pp.(!^"L:" ^^ State.Var.pp v)
+  | Right v -> Pp.(!^"R:" ^^ State.Var.pp v)
+
+  let ty = function Left v | Right v -> State.Var.ty v
+
+  let hash = Hashtbl.hash
+
+  let of_string s =
+    let v = State.Var.of_string @@ String.sub s 2 (String.length s - 2) in
+    match String.sub s 0 2 with
+    | "L:" -> Left v
+    | "R:" -> Right v
+    | _ -> Raise.inv_arg "Invalid variable: %s" s
+end
+
+module Exp = struct
+  include Exp.Make (Var)
+
+  let left : State.Exp.t -> t = Ast.Manip.exp_map_var (fun v -> Var.Left v)
+
+  let right : State.Exp.t -> t = Ast.Manip.exp_map_var (fun v -> Var.Right v)
+end
+
+module Z3sim = Z3.Make (Var)
+
+type sem_type =
+| Value of int
+| Ptr of sem_type
+
+type value_relation =
+| Eq
+| EqSection of string
+| EqPage of string
+| Indirect of sem_type
+
+let rec pp_sem_type = Pp.(function
+| Value w -> !^"Val"^^(int w)
+| Ptr typ -> (pp_sem_type typ)^^(!^"*")
+)
+
+let pp_rel = Pp.(function
+| Eq -> !^"Eq"
+| EqSection s -> !^"EqSection " ^^ !^s
+| EqPage s -> !^"EqPage " ^^ !^s
+| Indirect typ -> !^"Indirect " ^^ (pp_sem_type typ)
+)
+
+let rec sem_type_of_type (typ: Ctype.t) : sem_type =
+  match typ.unqualified with
+  | Ctype.Machine _ | Ctype.Cint _ | Ctype.Cbool | Ctype.Enum _ -> Value (Ctype.sizeof typ)
+  | Ptr { fragment=Ctype.DynArray typ'; _ } -> Ptr (sem_type_of_type typ')
+  | _ -> Raise.todo()
+
+let value_rel_for_type: Ctype.unqualified -> value_relation = function
+| Ctype.Machine _ | Ctype.Cint _ | Ctype.Cbool | Ctype.Enum _ -> Eq
+| Ptr { fragment=Ctype.Global s; _ } -> EqSection s
+| Ptr { fragment=Ctype.DynFragment i; _ } -> EqSection ("Dyn_"^string_of_int i)
+| Ptr { fragment=Ctype.DynArray typ'; _ } -> Indirect (sem_type_of_type typ')
+| _ -> Raise.todo()
+
+exception SimulationFailure of string
+
+let fail_sim fmt =
+  let fail msg = raise(SimulationFailure msg) in
+  Printf.ksprintf fail fmt
+
+let pp_diff pre pp l r =
+  let open Pp in
+  surround 2 2
+    pre
+    (!^"L: "^^pp l ^^ space ^^ !^"R: "^^pp r)
+    empty
+
+module ExpRel = struct
+  type t = State.exp * value_relation * State.exp
+
+  let to_exp ((exp1, rel, exp2):t) =
+    let open Option in
+    let modify e =
+      match rel with
+      | Eq -> e |> some
+      | EqSection s -> Typed.(e - State.Exp.of_var (State.Var.Section s)) |> some
+      (* TODO this is probably wrong: *)
+      | EqPage s -> Typed.(e - concat [extract ~first:12 ~last:63 (State.Exp.of_var (State.Var.Section s)); bits_int ~size:12 0]) |> some
+      | Indirect _ -> None
+    in
+    let+ e1, e2 = lift_pair (modify exp1, modify exp2) in
+    Typed.((Exp.left e1) = (Exp.right e2))
+ 
+  let pp ((a, r, b):t) =
+    let open Pp in
+    pp_diff
+      (pp_rel r ^^ !^" between")
+      Exp.pp (Exp.left a) (Exp.right b)
+end
+
+module RegRel = struct
+  type t = value_relation State.Reg.Map.t
+
+  let special_regs = ["OSDLR_EL1"; "OSLSR_EL1"; "EDSCR"; "SCR_EL3"]
+
+  let infer_from_types (s:State.t) =
+    State.Reg.Map.mapi (fun reg (r:State.Tval.t) ->
+      if List.exists ((=) (State.Reg.to_string reg)) special_regs then
+        Some Eq
+      else
+        Option.map (fun (r:Ctype.t) ->
+          value_rel_for_type r.unqualified
+        ) r.ctyp
+    ) s.regs
+
+  let to_exp_rel (s1:State.t) (s2:State.t) reg_rel : ExpRel.t list =
+    let bindings = State.Reg.Map.bindings reg_rel in
+    List.filter_map (fun (reg, rel) ->
+      Option.map (fun rel ->
+        State.get_reg_exp s1 reg, rel, State.get_reg_exp s2 reg
+      ) rel
+    ) bindings
+end
+
+module StackRel = struct
+  module RelMap = RngMap.Make (struct
+    type t = value_relation * int
+    let len (_, sz: t) = sz
+  end)
+  type t = RelMap.t
+
+  type loc = { offset:int; size:int }
+
+  module Event = State.Mem.Fragment.Event
+
+  let loc_of_blocks (blk1:State.Mem.Fragment.Block.t) (blk2:State.Mem.Fragment.Block.t) =
+    if Option.is_some blk1.base || Option.is_some blk2.base then
+      Raise.todo();
+    if blk1.offset != blk2.offset || blk1.size != blk2.size then
+      fail_sim "blocks don't match (%d, %t bytes) (%d, %t bytes)"
+        blk1.offset (Pp.tos Ast.Size.pp_bytes blk1.size)
+        blk2.offset (Pp.tos Ast.Size.pp_bytes blk2.size);
+    { offset=blk1.offset; size=Ast.Size.to_bytes blk1.size }
+
+  let rel_at_loc stack loc =
+    let open Option in
+    let* ((rel, relsz), reloff) = RelMap.at_off_opt stack loc.offset in
+    if loc.size != relsz || reloff != 0 then
+      (warn "Size not matching"; None)
+    else
+      Some rel
+  
+  let clear_loc stack loc =
+    RelMap.clear stack ~pos:loc.offset ~len:loc.size  
+  
+  let infer_from_types ~stack_frag (st1:State.t) =
+    let frag = Vec.get st1.fenv.frags stack_frag in
+    let stack = ref RelMap.empty in
+    State.Fragment.iteri (fun off ctype ->
+      stack := RelMap.add !stack off (value_rel_for_type ctype.unqualified, Ctype.len ctype)
+    ) frag;
+    !stack
+end
+
+module GlobalRel = struct
+  type eq_pair = State.exp * State.exp * sem_type
+
+  type t = eq_pair list
+
+  let find ~hyps (rel:t) a1 a2 =
+    let check_one a1 a2 (a1', a2', typ) =
+      debug "%t %t %t %t" (Pp.top State.Exp.pp a1) (Pp.top State.Exp.pp a2) (Pp.top State.Exp.pp a1') (Pp.top State.Exp.pp a2');
+      let equal = Z3sim.check_full ~hyps Typed.(manyop Ast.And [Exp.left a1= Exp.left a1'; Exp.right a2= Exp.right a2']) in
+      match equal with
+      | Some true -> Some typ
+      | _ -> None
+    in
+    List.find_map (check_one a1 a2) rel
+  
+  let add (rel:t) ((a1, a2, typ): eq_pair) =
+    (a1, a2, typ)::rel
+
+  let check ~hyps (rel:t) ((a1, a2, typ): eq_pair) =
+    Option.map ((=) typ) (find ~hyps rel a1 a2)
+  
+  let rel_of_sem_type = function
+  | Ptr t -> Indirect t
+  | Value _ -> Eq
+end
+
+let block_addr (blk : State.Mem.Fragment.Block.t) =
+  let ext = 64-Arch.address_size in
+  match blk.base with
+  | None -> Typed.bits_int ~size:64 blk.offset
+  | Some b -> Typed.(unop (Ast.ZeroExtend ext) b + bits_int ~size:64 blk.offset)
+
+let ptr_safety_asserts typ v =
+  let sz = match typ with
+  | Value x -> x
+  | Ptr _ -> 8 (*assume 64 bit pointers*)
+  in
+  let topbits = (64 - Arch.address_size) in
+  let small_enough = Typed.(extract ~first:Arch.address_size ~last:63 v = zero ~size:topbits) in
+  
+  let last = sz - 1 in
+  let aligned = Typed.(extract ~first:0 ~last v = zero ~size:sz) in
+  
+  [small_enough; aligned]
+
+module Context = struct
+  type t = {
+    asserts: Exp.t list;
+    stack: StackRel.t;
+    global: GlobalRel.t;
+  }
+
+  module Event = State.Mem.Fragment.Event
+
+  let add_expr_rel (ctxt:t) rel =
+    match rel with
+    | (v1, Indirect t, v2) ->
+        let safety1 = ptr_safety_asserts t v1 |> List.map Exp.left in
+        let safety2 = ptr_safety_asserts t v2 |> List.map Exp.right in
+        let nullptrs = Typed.((Exp.left v1 = zero ~size:64) = (Exp.right v2 = zero ~size:64)) in
+        { 
+          asserts = safety1 @ safety2 @ nullptrs::ctxt.asserts;
+          global = GlobalRel.add ctxt.global (v1, v2, t);
+          stack = ctxt.stack;
+        }
+    | rel ->
+        let exp = Option.value_fail (ExpRel.to_exp rel) "Failed to convert relation to expression" in
+        { ctxt with asserts = exp::ctxt.asserts }
+  
+  let check_expr_rel (ctxt:t) rel =
+    match rel with
+    | (v1, Indirect t, v2) ->
+        GlobalRel.check ~hyps:ctxt.asserts ctxt.global (v1, v2, t)
+    | rel ->
+        let exp = Option.value_fail (ExpRel.to_exp rel) "Failed to convert relation to expression" in
+        Z3sim.check_full ~hyps:ctxt.asserts exp
+
+  let process_stack_operation event1 event2 (ctxt: t) =
+    match event1, event2 with
+    | Event.Read (blk1, v1), Event.Read (blk2, v2) ->
+        let loc = StackRel.loc_of_blocks blk1 blk2 in
+        let rel = StackRel.rel_at_loc ctxt.stack loc in
+        ( match rel with
+        | Some rel -> add_expr_rel ctxt (State.Exp.of_var v1, rel, State.Exp.of_var v2)
+        | None -> (debug "No relation for stack read %t %t" (Pp.top Event.pp event1) (Pp.top Event.pp event2); ctxt)
+        )
+    | Event.Write (blk1, _exp1), Event.Write (blk2, _exp2) ->
+        let loc = StackRel.loc_of_blocks blk1 blk2 in
+        { ctxt with stack = StackRel.clear_loc ctxt.stack loc}
+    | _ -> fail_sim "traces don't match %t %t" (Pp.tos Event.pp event1) (Pp.tos Event.pp event2)
+  
+  let process_global_operation event1 event2 (ctxt: t) =
+    match event1, event2 with
+    | Event.Read (blk1, v1), Event.Read (blk2, v2) ->
+        let addr1 = block_addr blk1 in
+        let addr2 = block_addr blk2 in
+        let typ = GlobalRel.find ~hyps:ctxt.asserts ctxt.global addr1 addr2 in
+        ( match typ with
+        | Some typ ->
+            let rel = GlobalRel.rel_of_sem_type typ in
+            add_expr_rel ctxt (State.Exp.of_var v1, rel, State.Exp.of_var v2)
+        | None -> (warn "No relation for global read %t %t" (Pp.top Event.pp event1) (Pp.top Event.pp event2); ctxt)
+        )
+    | Event.Write (blk1, exp1), Event.Write (blk2, exp2) ->
+        let addr1 = block_addr blk1 in
+        let addr2 = block_addr blk2 in
+        let typ = GlobalRel.find ~hyps:ctxt.asserts ctxt.global addr1 addr2 in
+        ( match typ with
+        | Some typ ->
+            let rel = GlobalRel.rel_of_sem_type typ in
+            if check_expr_rel ctxt (exp1, rel, exp2) <> Some true then
+              fail_sim "Unable to verify %t" (Pp.tos ExpRel.pp (exp1, rel, exp2))
+        | None -> fail_sim "Unable to determine target type for global write %t %t" (Pp.tos Event.pp event1) (Pp.tos Event.pp event2)
+        );
+        ctxt
+    | _ -> fail_sim "traces don't match %t %t" (Pp.tos Event.pp event1) (Pp.tos Event.pp event2)
+
+  let infer_from_types ~stack_frag ~(dwarf:Dw.t) (state: State.t) =
+    let stack = StackRel.infer_from_types state ~stack_frag in
+
+    let regs = RegRel.infer_from_types state in
+    let register_rels = RegRel.to_exp_rel state state regs in
+
+    let global_variable_rels =
+      Hashtbl.to_seq_values dwarf.vars
+      |> Seq.map (fun (v:Dw.Var.t) ->
+        let typ = sem_type_of_type v.ctype in
+        match v.locs with
+        | [_, Global addr] ->
+            let addr = Elf.SymTable.to_addr_offset addr in
+            let exp = State.Exp.of_address ~size:64 addr in
+            (exp, Indirect typ, exp)
+        | _ ->
+            Raise.fail "Weird location description for global variable: %t" (Pp.tos Dw.Var.pp_raw v);
+      )
+      |> List.of_seq
+    in
+
+    let ctxt = { stack; asserts=[]; global=[] } in
+    List.fold_left add_expr_rel ctxt (register_rels @ global_variable_rels)
+end
+
+type simrel = (State.Id.t*State.Id.t, Context.t) Hashtbl.t
+
+let stack_prov = 0(* TODO determine stack_frag automatically *)
+let stack_frag = 0(* TODO determine stack_frag automatically *)
+
+exception SimulationFailureWithContext of {
+  msg:string;
+  states: State.t * State.t;
+  ctxt: Context.t;
+}
+
+let rec checksim ~(rel:simrel) (s1:State.t) (s2:State.t) =
+  Hashtbl.find_opt rel (s1.id, s2.id)
+  |> Option.value_fun ~default:(fun() ->
+    let bs1 = Option.value_fail s1.base_state "no base state" in
+    let bs2 = Option.value_fail s2.base_state "no base state" in
+    let prev_ctxt = checksim ~rel bs1 bs2 in
+    try
+
+      (* Process stack trace *)
+      let ((_,mem1), (_,mem2)) = State.Mem.(get_frag s1.mem stack_prov, get_frag s2.mem stack_prov) in
+      let (trc1, trc2) = State.Mem.Fragment.(get_trace mem1, get_trace mem2) in
+
+      let ctxt = List.fold_right2 Context.process_stack_operation trc1 trc2 prev_ctxt in
+
+      (* Process global trace *)
+      let (mem1, mem2) = State.Mem.(get_main s1.mem, get_main s2.mem) in
+      let (trc1, trc2) = State.Mem.Fragment.(get_trace mem1, get_trace mem2) in
+
+      let ctxt = List.fold_right2 Context.process_global_operation trc1 trc2 ctxt in
+
+
+      let asst1 = List.map Exp.left s1.asserts in
+      let asst2 = List.map Exp.right s2.asserts in
+      let impl1 = List.find_all Fun.(Z3sim.check_full ~hyps:(asst1@ctxt.asserts) %> flip Option.value_fail "TODO: Z3 failed" %> not) asst2 in
+      let impl2 = List.find_all Fun.(Z3sim.check_full ~hyps:(asst2@ctxt.asserts) %> flip Option.value_fail "TODO: Z3 failed" %> not) asst1 in
+      if not (List.is_empty impl1 && List.is_empty impl2) then
+        fail_sim "%t" Pp.(Fun.const @@ sprint @@ pp_diff
+          !^"States not equivalent on path conditions"
+          (list Exp.pp)
+          impl2
+          impl1
+      );
+
+      Hashtbl.add rel (s1.id, s2.id) ctxt;
+      ctxt
+    with
+    | SimulationFailure s -> raise @@ SimulationFailureWithContext {
+        msg=s;
+        states=(s1,s2);
+        ctxt=prev_ctxt;
+      }
+  )
+
+let check_return_values ~(ret_reg) ~(ret_type:Ctype.t) ~(rel:simrel) (s1:State.t) (s2:State.t) =
+  let ctxt = Hashtbl.find rel (s1.id, s2.id) in
+
+  let ret_val1 = State.get_reg_exp s1 ret_reg in
+  let ret_val2 = State.get_reg_exp s2 ret_reg in
+  let rel = value_rel_for_type ret_type.unqualified in
+
+  if Context.check_expr_rel ctxt (ret_val1, rel, ret_val2) <> Some true then
+    raise @@ SimulationFailureWithContext {
+      msg=Printf.sprintf "Return values not equivalent
+Condition: %t\n" (Pp.tos ExpRel.pp (ret_val1, rel, ret_val2));
+      states=(s1,s2);
+      ctxt=ctxt;
+    }
+
+
+let run elf name =
+  let dwarf = Dw.of_file elf in
+  let tree = Run.Func.get_state_tree ~elf ~name () in
+  let initial_state = tree.state in
+  
+  let initial_ctxt = Context.infer_from_types ~stack_frag ~dwarf initial_state in
+
+  let simrel:simrel = Hashtbl.create 10 in
+  Hashtbl.add simrel (initial_state.id, initial_state.id) initial_ctxt;
+
+  debug "%t" (Pp.top (State.Tree.pp_all Run.Block_lib.pp_label) tree);
+
+  let ret = Option.(
+    let* func =Dw.get_func_opt ~name dwarf in
+    let+ typ = func.func.ret in
+    if Ctype.sizeof typ > 8 then
+      Raise.fail "unsupported return type %t" (Pp.tos Ctype.pp typ)
+    else
+      ((Arch.dwarf_reg_map()).(0), typ)
+  ) in
+
+  try
+    State.Tree.prefix_iter (fun _ s ->
+      checksim ~rel:simrel s s |> ignore;
+      if State.get_reg_exp s (Arch.pc()) = State.Exp.of_var State.Var.RetAddr then
+        Option.iter (fun (ret_reg, ret_type) ->
+          check_return_values ~ret_reg ~ret_type ~rel:simrel s s;
+        ) ret
+    ) tree;
+    base "Simulation successful"
+  with
+  | SimulationFailureWithContext e ->
+      let st, _ = e.states in
+      debug "Failing state: %t" (Pp.top State.pp st);
+      base "Simulation failed:\n\n%s" e.msg
+
+let elf =
+  let doc = "ELF file from which to pull the code" in
+  Arg.(required & pos 0 (some non_dir_file) None & info [] ~docv:"ELF_FILE" ~doc)
+
+let func =
+  let doc = "Symbol name of the function to run" in
+  Arg.(value & pos 1 string "main" & info [] ~docv:"FUNCTION" ~doc)
+
+let term =
+  Term.(
+    CmdlinerHelper.func_options comopts run
+    $ elf $ func)
+
+let info =
+  let doc =
+    "Simulation relation on relocatable binary"
+  in
+  Cmd.(info "relsim" ~doc ~exits)
+
+let command = (term, info)
diff --git a/src/state/base.ml b/src/state/base.ml
index 2657fa7d..17659776 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -328,6 +328,10 @@ module Mem = struct
   (** Get the main fragment of memory *)
   let get_main { main; _ } = main
 
+  (** Get fragment *)
+  let get_frag mem i =
+    Vec.get mem.frags i
+
   (** Empty memory, every address is unbound *)
   let empty () = { main = Fragment.empty; frags = Vec.empty (); sections = Hashtbl.create 10; allow_main = true }
 
diff --git a/src/state/base.mli b/src/state/base.mli
index 2d373fd4..73d6c370 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -259,6 +259,9 @@ module Mem : sig
 
   (** Get the main fragment of memory *)
   val get_main : t -> Fragment.t
+
+  (** Get fragment *)
+  val get_frag : t -> int -> Exp.t * Fragment.t 
 end
 
 (** {1 State type } *)
diff --git a/src/state/reg.mli b/src/state/reg.mli
index fd67c573..b9692051 100644
--- a/src/state/reg.mli
+++ b/src/state/reg.mli
@@ -216,6 +216,9 @@ module Map : sig
   (** Map the function all the registers (including future, not yet added ones) *)
   val map : ('a -> 'b) -> 'a t -> 'b t
 
+  (** Same as {!map} but with the index *)
+  val mapi : (reg -> 'a -> 'b) -> 'a t -> 'b t
+
   (** Map the function on all the register by mutation (including future ones) *)
   val map_mut : ('a -> 'a) -> 'a t -> unit
 
diff --git a/src/state/symbolicFragment.ml b/src/state/symbolicFragment.ml
index dbc941fa..40ef78f2 100644
--- a/src/state/symbolicFragment.ml
+++ b/src/state/symbolicFragment.ml
@@ -98,6 +98,8 @@ module type S = sig
     type t =
       | Read of Block.t * var  (** From [Block.t], read [var] *)
       | Write of Block.t * exp  (** To [Block.t], write [exp] *)
+
+    val pp : t -> Pp.document
   end
 
   (** The type of a memory fragment *)
diff --git a/src/trace/context.ml b/src/trace/context.ml
index 2fe350d4..59950dc2 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -106,6 +106,9 @@ let typing_enabled ~(ctxt : t) = ctxt.dwarf <> None
 module Z3St = State.Simplify.Z3St
 
 let simplify ~(ctxt : t) (exp : State.exp) : State.exp =
+  debug "Before simplification: %t" (Pp.top State.Exp.pp exp);
+  debug "Before simplification: %t" (Pp.top State.Exp.pp (Z3St.simplify_full exp));
   exp
   |> Z3St.simplify_subterms_full ~hyps:ctxt.asserts
-  |> Z3St.simplify_full
\ No newline at end of file
+  |> Z3St.simplify_full
+  |> Fun.tee (fun e -> debug "After simplification: %t" (Pp.top State.Exp.pp e))
\ No newline at end of file
diff --git a/src/utils/fullVec.ml b/src/utils/fullVec.ml
index f6bea2c1..998e2232 100644
--- a/src/utils/fullVec.ml
+++ b/src/utils/fullVec.ml
@@ -107,6 +107,11 @@ let map f fv =
   let gen = fv.gen %> f in
   { vec; gen }
 
+let mapi f fv =
+  let vec = Vec.mapi f fv.vec in
+  let gen = (fun i -> fv.gen i |> f i) in
+  { vec; gen }
+
 let map_mut f fv =
   Vec.map_mut f fv.vec;
   fv.gen <- fv.gen %> f
diff --git a/src/utils/fullVec.mli b/src/utils/fullVec.mli
index 51d9f079..9a67676f 100644
--- a/src/utils/fullVec.mli
+++ b/src/utils/fullVec.mli
@@ -89,6 +89,9 @@ val get_vec_until : 'a t -> int -> 'a Vec.t
 (** Map the function over the fullvec. Postcompose the map on the generator *)
 val map : ('a -> 'b) -> 'a t -> 'b t
 
+(** Same as {!map} but with the index *)
+val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
+
 (** Map the function over the fullvector by mutation. Postcompose the map on the generator.contents
     Warning, a lot of {!map_mut} may make the generator big and slow.
     Maybe try to use {!set_after} to reset it when required.*)

From 0d7f6b19051fc66d06a7cb8834e1e5598047f194 Mon Sep 17 00:00:00 2001
From: maturvo <59334936+maturvo@users.noreply.github.com>
Date: Tue, 13 May 2025 01:53:03 +0100
Subject: [PATCH 089/116] Fix analyse (#3)

---
 src/analyse/CallGraph.ml             |   6 +-
 src/analyse/ControlFlow.ml           | 108 ++++++++++++++++++++-------
 src/analyse/ControlFlowTypes.ml      |   1 +
 src/analyse/DwarfFrameInfo.ml        |   7 +-
 src/analyse/DwarfInliningInfo.ml     |   6 +-
 src/analyse/DwarfLineInfo.ml         |   6 +-
 src/analyse/DwarfVarInfo.ml          |   8 +-
 src/analyse/Pp.ml                    |  14 +++-
 src/analyse/html-preamble-insts.html |   3 +
 src/utils/sym.ml                     |  36 ++++++---
 10 files changed, 141 insertions(+), 54 deletions(-)

diff --git a/src/analyse/CallGraph.ml b/src/analyse/CallGraph.ml
index 026db808..1a070b26 100644
--- a/src/analyse/CallGraph.ml
+++ b/src/analyse/CallGraph.ml
@@ -110,7 +110,7 @@ let mk_call_graph test (an : CollectedType.analysis) =
                        if
                          not
                            (List.exists
-                              (function (a'', _) -> Sym.equal a' a'')
+                              (function (a'', _) -> Sym.Ordered.equal a' a'')
                               elf_symbols)
                        then Some (a', ["FROM BL:" ^ s'])
                        else None)
@@ -122,7 +122,7 @@ let mk_call_graph test (an : CollectedType.analysis) =
     match axs with
     | [] -> acc
     | (a, x) :: axs' ->
-        if not (List.exists (function (a', _) -> Sym.equal a a') acc) then
+        if not (List.exists (function (a', _) -> Sym.Ordered.equal a a') acc) then
           dedup axs' ((a, x) :: acc)
         else dedup axs' acc
   in
@@ -133,7 +133,7 @@ let mk_call_graph test (an : CollectedType.analysis) =
     List.sort
       (function
         | (a, _) -> (
-            function (a', _) -> Sym.compare a a'
+            function (a', _) -> Sym.Ordered.compare a a'
           ))
       (elf_symbols @ extra_bl_targets)
   in
diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index bba61c63..8eefb233 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -295,9 +295,9 @@ with
   (Scanf.Scan_failure _ | End_of_file)  ->
    Scanf.sscanf s "%Lx" (fun i64 -> Sym.of_int64 i64)
 
-let parse_target s =
+let parse_target base s =
   match Scanf.sscanf s " %s %s" (fun s1 s2 -> (s1, s2)) with
-  | (s1, s2) -> Some (parse_addr s1, s2)
+  | (s1, s2) -> Some (Sym.add base (parse_addr s1), s2)
   | exception _ -> None
 
 let parse_drop_one s =
@@ -309,7 +309,20 @@ let parse_drop_one s =
   | (_, s') -> Some s'
   | exception _ -> None
 
-let parse_control_flow_instruction s mnemonic s' : control_flow_insn =
+let parse_relocation_target symbol_map s =
+  let s, offset = match String.split_on_char '+' s with
+  | [s1; s2] ->
+      s1, Scanf.sscanf s2 "0x%x" Fun.id
+  | [s] -> s, 0
+  | _ -> fatal "Unable to parse relocation target '%s'" s
+  in
+  let addr = List.find_map (fun (name, (_,_,addr,_,_)) -> if name = s then Some addr else None) symbol_map in
+  Option.map (Sym.add (Sym.of_int offset)) addr
+
+let parse_control_flow_instruction symbol_map base s mnemonic s' relocation : control_flow_insn =
+  let relocation_target = Option.bind relocation (fun (_typ, target) ->
+    Option.map (fun a -> (a, target)) (parse_relocation_target symbol_map target)
+  ) in
   (*   Printf.printf "s=\"%s\" mnemonic=\"%s\"  mnemonic chars=\"%s\" s'=\"%s\"   "s mnemonic (String.concat "," (List.map (function c -> string_of_int (Char.code c)) (char_list_of_string mnemonic))) s';flush stdout;*)
   let c =
     if List.mem String.equal mnemonic [".word"] then C_no_instruction
@@ -320,9 +333,9 @@ let parse_control_flow_instruction s mnemonic s' : control_flow_insn =
       (String.length mnemonic >= 2 && String.sub mnemonic 0 2 = "b.")
       || List.mem String.equal mnemonic ["b"; "bl"]
     then
-      match parse_target s' with
-      | None -> raise (Failure ("b./b/bl parse error for: \"" ^ s ^ "\"\n"))
-      | Some (a, s) ->
+      match parse_target base s', relocation_target with
+      | None, None -> raise (Failure ("b./b/bl parse error for: \"" ^ s ^ "\"\n"))
+      | _, Some(a, s) | Some (a, s), None ->
           if mnemonic = "b" then C_branch (a, s)
           else if mnemonic = "bl" then C_branch_and_link (a, s)
           else C_branch_cond (mnemonic, a, s)
@@ -330,9 +343,9 @@ let parse_control_flow_instruction s mnemonic s' : control_flow_insn =
       match parse_drop_one s' with
       | None -> raise (Failure ("cbz/cbnz 1 parse error for: " ^ s ^ "\n"))
       | Some s' -> (
-          match parse_target s' with
-          | None -> raise (Failure ("cbz/cbnz 2 parse error for: " ^ s ^ "\n"))
-          | Some (a, s) -> C_branch_cond (mnemonic, a, s)
+          match parse_target base s', relocation_target with
+          | None, None -> raise (Failure ("cbz/cbnz 2 parse error for: " ^ s ^ "\n"))
+          | _, Some(a, s) | Some (a, s), None -> C_branch_cond (mnemonic, a, s)
         )
     else if List.mem String.equal mnemonic ["tbz"; "tbnz"] then
       match parse_drop_one s' with
@@ -341,9 +354,9 @@ let parse_control_flow_instruction s mnemonic s' : control_flow_insn =
           match parse_drop_one s'' with
           | None -> raise (Failure ("tbz/tbnz 2 parse error for: " ^ s ^ "\n"))
           | Some s''' -> (
-              match parse_target s''' with
-              | None -> raise (Failure ("tbz/tbnz 3 parse error for: " ^ s ^ "\n"))
-              | Some (a, s'''') ->
+              match parse_target base s''', relocation_target with
+              | None, None -> raise (Failure ("tbz/tbnz 3 parse error for: " ^ s ^ "\n"))
+              | _, Some(a, s'''') | Some (a, s''''), None ->
                   (*                Printf.printf "s=%s mnemonic=%s s'=%s s''=%s s'''=%s s''''=%s\n"s mnemonic s' s'' s''' s'''';*)
                   C_branch_cond (mnemonic, a, s'''')
             )
@@ -438,14 +451,21 @@ AArch64:
    10004:	52800129 	mov	w9, #0x9                   	// #9
  *)
 
+let relocation_regexp_string = "[ \t][0-9a-fA-F]+:[ \t]\\([0-9A-Z_]+\\)\t\\(.*\\)"
+
 let objdump_line_regexp =
-  Str.regexp " *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\) *\\(.*\\)$"
+  Str.regexp (" *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\)[ \t]*\\([^:]*\\)\\(" ^ relocation_regexp_string ^ "\\)?$")
 
 let section_start_line_regexp =
   Str.regexp "Disassembly of section \\(.*\\):$"
 
+type relocation = string * string
+
+type raw_objdump_instruction =
+  int64 (*address*) * int list (*opcode bytes*) * string (*mnemonic*) * string * relocation option
+
 type objdump_instruction =
-  natural (*address*) * int list (*opcode bytes*) * string (*mnemonic*) * string
+  natural (*address*) * int list (*opcode bytes*) * string (*mnemonic*) * string * relocation option
 
 (*args etc*)
 
@@ -455,7 +475,7 @@ let parse_section_start s =
   else
     None
 
-let parse_objdump_line (s : string) : (int64 * int list * string * string) option =
+let parse_objdump_line (s : string) : raw_objdump_instruction option =
   let parse_hex_int64 s' =
     try Scanf.sscanf s' "%Lx" (fun i64 -> i64)
     with _ -> fatal "cannot parse address in objdump line %s\n" s
@@ -474,6 +494,7 @@ let parse_objdump_line (s : string) : (int64 * int list * string * string) optio
   in
   if Str.string_match objdump_line_regexp s 0 then
     begin
+      (* debug "matched line"; *)
       let addr_int64 = parse_hex_int64 (Str.matched_group 1 s) in
       let op = Str.matched_group 2 s in
       let op = strip_whitespace op in
@@ -486,17 +507,43 @@ let parse_objdump_line (s : string) : (int64 * int list * string * string) optio
       let opcode_bytes = List.map parse_hex_int opcode_byte_strings in
       let mnemonic = Str.matched_group 3 s in
       let operands = Str.matched_group 4 s in
-      Some (addr_int64, opcode_bytes, mnemonic, operands)
+      let relocation = try
+        Some (Str.matched_group 6 s, Str.matched_group 7 s)
+      with
+      | Not_found -> None
+      in
+      Some (addr_int64, opcode_bytes, mnemonic, operands, relocation)
     end
   else None
 
+(* let parse_objdump_relocation (s : string) : (string * string) option =
+  let parse_hex_int s' =
+    try Scanf.sscanf s' "%x" (fun i -> i)
+    with _ -> fatal "cannot parse relocation '%s' in objdump line %s\n" s' s
+  in
+  if Str.string_match objdump_line_regexp s 0 then
+    begin
+      let addr = Str.matched_group 1 s in
+      let op = Str.matched_group 2 s in
+      let op = strip_whitespace op in
+      let opcode_byte_strings =
+        [String.sub op 0 2;
+         String.sub op 2 2;
+         String.sub op 4 2;
+         String.sub op 6 2]
+      in
+      let opcode_bytes = List.map parse_hex_int opcode_byte_strings in
+      Some (addr, op)
+    end
+  else None *)
+
 (*
 let parse_objdump_lines arch lines : objdump_instruction list =
   List.filter_map (parse_objdump_line arch) (Array.to_list lines)
  *)
 
-let with_symbolic_address (section: string) (addr, opcode_bytes, mnemonic, operands) : objdump_instruction =
-  (Sym_ocaml.Num.Offset (section, Nat_big_num.of_int64 addr), opcode_bytes, mnemonic, operands)
+let with_symbolic_address (section: string) (addr, opcode_bytes, mnemonic, operands, relocation) : objdump_instruction =
+  (Sym_ocaml.Num.Offset (section, Nat_big_num.of_int64 addr), opcode_bytes, mnemonic, operands, relocation)
 
 let rec parse_objdump_lines arch lines (next_index : int) (last_address : int64 option) (section: string option) :
     objdump_instruction list =
@@ -506,7 +553,7 @@ let rec parse_objdump_lines arch lines (next_index : int) (last_address : int64
     match parse_objdump_line lines.(next_index) with
     (* skip over unparseable lines *)
     | None -> parse_objdump_lines arch lines (next_index + 1) last_address section
-    | Some ((addr, _opcode_bytes, _mnemonic, _operands) as i) -> (
+    | Some ((addr, _opcode_bytes, _mnemonic, _operands, _relocation) as i) -> (
         let mki = with_symbolic_address (Option.get section) in
         match last_address with
         | None -> mki i :: parse_objdump_lines arch lines (next_index + 1) (Some addr) section
@@ -515,7 +562,7 @@ let rec parse_objdump_lines arch lines (next_index : int) (last_address : int64
             if addr > last_address'' then
               (* fake up "missing" instructions for any gaps in the address space*)
               (*warn "gap in objdump instruction address sequence at %s" (pp_addr last_address'');*)
-              mki (last_address'', [], "missing", "")
+              mki (last_address'', [], "missing", "", None)
               :: parse_objdump_lines arch lines next_index (Some last_address'') section
             else mki i :: parse_objdump_lines arch lines (next_index + 1) (Some addr) section
       )
@@ -546,7 +593,7 @@ let mk_instructions test filename_objdump_d filename_branch_table_option :
     Array.iteri
       (function
         | k -> (
-            function (addr, _, _, _) -> Hashtbl.add tbl addr k
+            function (addr, _, _, _, _) -> Hashtbl.add tbl addr k
           ))
       objdump_instructions;
     ( (function
@@ -563,9 +610,14 @@ let mk_instructions test filename_objdump_d filename_branch_table_option :
   let instructions =
     Array.map
       (function
-        | (addr, opcode_bytes, mnemonic, operands) ->
+        | (addr, opcode_bytes, mnemonic, operands, relocation) ->
+            (* a bit hacky *)
+            let base = match addr with
+            | Sym_ocaml.Num.Offset(s,_) -> Sym_ocaml.Num.section s
+            | Sym_ocaml.Num.Absolute(_) -> Sym.of_int 0
+            in
             let c : control_flow_insn =
-              parse_control_flow_instruction ("objdump line " ^ pp_addr addr) mnemonic operands
+              parse_control_flow_instruction test.symbol_map base ("objdump line " ^ pp_addr addr) mnemonic operands relocation
             in
 
             let targets =
@@ -579,12 +631,18 @@ let mk_instructions test filename_objdump_d filename_branch_table_option :
               i_operands = operands;
               i_control_flow = c;
               i_targets = targets;
+              i_relocation = relocation;
             })
       objdump_instructions
   in
 
   let address_of_index k = instructions.(k).i_addr in
 
+  Array.sort
+    (fun i1 i2 ->
+      Sym.Ordered.compare (i1.i_addr) (i2.i_addr))
+    instructions;
+
   (instructions, index_of_address, index_option_of_address, address_of_index)
 
 (* pull out indirect branches *)
@@ -616,11 +674,11 @@ let highlight c =
 
 (* highlight branch targets to earlier addresses*)
 let pp_target_addr_wrt (addr : natural) (c : control_flow_insn) (a : natural) =
-  (if highlight c && Sym.less a addr then "^" else "") ^ pp_addr a
+  (if highlight c && Sym.Ordered.less a addr then "^" else "") ^ pp_addr a
 
 (* highlight branch come-froms from later addresses*)
 let pp_come_from_addr_wrt (addr : natural) (c : control_flow_insn) (a : natural) =
-  (if highlight c && Sym.greater a addr then "v" else "") ^ pp_addr a
+  (if highlight c && Sym.Ordered.greater a addr then "v" else "") ^ pp_addr a
 
 (*
 let pp_branch_targets (xs : (addr * control_flow_insn * (target_kind * addr * int * string) list) list)
diff --git a/src/analyse/ControlFlowTypes.ml b/src/analyse/ControlFlowTypes.ml
index 97815632..4ecb695f 100644
--- a/src/analyse/ControlFlowTypes.ml
+++ b/src/analyse/ControlFlowTypes.ml
@@ -83,6 +83,7 @@ type instruction = {
   i_operands : string;
   i_control_flow : control_flow_insn;
   i_targets : target list;
+  i_relocation : (string * string) option;
 }
 
 type come_from = {
diff --git a/src/analyse/DwarfFrameInfo.ml b/src/analyse/DwarfFrameInfo.ml
index 991b295d..63da2fc1 100644
--- a/src/analyse/DwarfFrameInfo.ml
+++ b/src/analyse/DwarfFrameInfo.ml
@@ -53,14 +53,15 @@ open ControlFlowTypes
 
 let aof ((a : natural), (_cfa : string), (_regs : (string * string) list)) = a
 
+(* TODO does Sym.Ordered work as we want? *)
 let rec f (aof : 'b -> natural) (a : natural) (last : 'b option) (bs : 'b list) : 'b option =
   match (last, bs) with
   | (None, []) -> None
-  | (Some b', []) -> if Sym.greater_equal a (aof b') then Some b' else None
+  | (Some b', []) -> if Sym.Ordered.greater_equal a (aof b') then Some b' else None
   | (None, b'' :: bs') -> f aof a (Some b'') bs'
   | (Some b', b'' :: bs') ->
-      if Sym.less a (aof b') then None
-      else if Sym.greater_equal a (aof b') && Sym.less a (aof b'') then Some b'
+      if Sym.Ordered.less a (aof b') then None
+      else if Sym.Ordered.greater_equal a (aof b') && Sym.Ordered.less a (aof b'') then Some b'
       else f aof a (Some b'') bs'
 
 let mk_frame_info test instructions :
diff --git a/src/analyse/DwarfInliningInfo.ml b/src/analyse/DwarfInliningInfo.ml
index 832b4cac..4180e17e 100644
--- a/src/analyse/DwarfInliningInfo.ml
+++ b/src/analyse/DwarfInliningInfo.ml
@@ -68,7 +68,7 @@ let mk_inlining test sdt instructions =
       let addr = i.i_addr in
       let issr_still_current =
         List.filter
-          (function (_label, ((_n1, n2), (_m, _n), _is)) -> Sym.less addr n2)
+          (function (_label, ((_n1, n2), (_m, _n), _is)) -> Sym.Ordered.less addr n2)
           issr_current
       in
 
@@ -83,8 +83,8 @@ let mk_inlining test sdt instructions =
 
       let (issr_starting_here0, issr_rest') =
         find_first
-          (function ((_n1, n2), (_m, _n), _is) -> Sym.less_equal n2 addr)
-          (function ((n1, _n2), (_m, _n), _is) -> Sym.equal n1 addr)
+          (function ((_n1, n2), (_m, _n), _is) -> Sym.Ordered.less_equal n2 addr)
+          (function ((n1, _n2), (_m, _n), _is) -> Sym.Ordered.equal n1 addr)
           [] issr_rest
       in
 
diff --git a/src/analyse/DwarfLineInfo.ml b/src/analyse/DwarfLineInfo.ml
index 7cb6bf73..2cbf4fef 100644
--- a/src/analyse/DwarfLineInfo.ml
+++ b/src/analyse/DwarfLineInfo.ml
@@ -269,11 +269,11 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
   let elifis = Array.make size [] in
 
   let sequences = List.flatten (List.map split_into_sequences eli) in
-  let compare_sequence s1 s2 = Sym.compare s1.elis_first s2.elis_first in
+  let compare_sequence s1 s2 = Sym.Ordered.compare s1.elis_first s2.elis_first in
   let sequences_sorted = List.sort compare_sequence sequences in
 
   let entries = List.flatten (List.map split_into_entries sequences_sorted) in
-  let compare_entry e1 e2 = Sym.compare e1.elie_first e2.elie_first in
+  let compare_entry e1 e2 = Sym.Ordered.compare e1.elie_first e2.elie_first in
   let entries_sorted = List.sort compare_entry entries in
 
   (*List.iter (function elie -> Printf.printf "%s" (pp_elie_concise elie)) entries_sorted;*)
@@ -286,7 +286,7 @@ let mk_line_info (eli : Dwarf.evaluated_line_info) instructions :
         match remaining with
         | [] -> (acc, remaining)
         | elie :: remaining' ->
-            if Sym.less_equal elie.elie_first addr then
+            if Sym.Ordered.less_equal elie.elie_first addr then
               mk_new_perhaps_relevant (elie :: acc) remaining'
             else (acc, remaining)
       in
diff --git a/src/analyse/DwarfVarInfo.ml b/src/analyse/DwarfVarInfo.ml
index 144e48b5..8e1ffbec 100644
--- a/src/analyse/DwarfVarInfo.ml
+++ b/src/analyse/DwarfVarInfo.ml
@@ -260,7 +260,7 @@ let pp_ranged_var (prefix : string) (var : ranged_var) : string =
 let pp_ranged_vars (prefix : string) (vars : ranged_var list) : string =
   String.concat "" (List.map (pp_ranged_var prefix) vars)
 
-let compare_pc_ranges ((n1, _, _), _) ((n1', _, _), _) = compare n1 n1'
+let compare_pc_ranges ((n1, _, _), _) ((n1', _, _), _) = Sym.Ordered.compare n1 n1'
 
 let local_by_pc_ranges (((svfp : Dwarf.sdt_variable_or_formal_parameter), _context) as var) :
     ranged_var list =
@@ -299,14 +299,14 @@ let mk_ranged_vars_at_instructions (sdt_d : Dwarf.sdt_dwarf) instructions :
     if k >= size then ()
     else
       let addr = instructions.(k).i_addr in
-      if not (Sym.less addr_prev addr) then
+      if not (Sym.Ordered.less addr_prev addr) then
         fatal "mk_ranged_vars_at_instructions found non-increasing address %s" (pp_addr addr);
       let (still_current, old) =
-        List.partition (function ((_, n2, _), _) -> Sym.less addr n2) prev
+        List.partition (function ((_, n2, _), _) -> Sym.Ordered.less addr n2) prev
       in
       let (new', remaining') =
         partition_first
-          (function ((n1, _n2, _ops), _var) as _rv -> Sym.greater_equal addr n1)
+          (function ((n1, _n2, _ops), _var) as _rv -> Sym.Ordered.greater_equal addr n1)
           remaining
       in
       (* TODO: do we need to drop any that have been totally skipped over? *)
diff --git a/src/analyse/Pp.ml b/src/analyse/Pp.ml
index 0bf41866..cc57b5f6 100644
--- a/src/analyse/Pp.ml
+++ b/src/analyse/Pp.ml
@@ -74,6 +74,7 @@ type render_kind =
   | Render_vars_old
   | Render_inlining
   | Render_ctrlflow
+  | Render_relocation
 
 let render_colour = function
   | Render_symbol_star -> "gold"
@@ -86,6 +87,7 @@ let render_colour = function
   | Render_vars_old -> "grey"
   | Render_inlining -> "red"
   | Render_ctrlflow -> "white"
+  | Render_relocation -> "purple"
 
 let render_class_name = function
   | Render_symbol_star -> "symbol-star"
@@ -98,6 +100,7 @@ let render_class_name = function
   | Render_vars_old -> "vars-old"
   | Render_inlining -> "inlining"
   | Render_ctrlflow -> "ctrlflow"
+  | Render_relocation -> "relocation"
 
 type html_idiom = HI_span | HI_pre | HI_classless_span | HI_font
 
@@ -327,13 +330,20 @@ let pp_instruction m test an rendered_control_flow_common_prefix_end k i =
       (ControlFlowPpText.pp_glyphs rendered_control_flow_common_prefix_end
          an.rendered_control_flow.(k))
   (* the address and (hex) instruction *)
-  ^ css m Render_instruction
-      (pp_addr addr ^ ":  "
+  ^ css m Render_instruction (
+      pp_addr addr ^ ":  "
       ^ pp_opcode_bytes test.arch i.i_opcode
       (* the dissassembly from objdump *)
       ^ "  "
       ^ i.i_mnemonic ^ "\t" ^ i.i_operands
       )
+  ^ css m Render_relocation
+      (match i.i_relocation with
+       | None -> ""
+       | Some (typ, targ) ->
+           "\t" ^ typ ^ " " ^ targ
+      )
+  (* the instruction's control flow *)
   (* any indirect-branch control flow from this instruction *)
   ^ css m Render_ctrlflow
       (begin
diff --git a/src/analyse/html-preamble-insts.html b/src/analyse/html-preamble-insts.html
index 36645dfd..3b8adb8b 100644
--- a/src/analyse/html-preamble-insts.html
+++ b/src/analyse/html-preamble-insts.html
@@ -81,6 +81,9 @@
       .ctrlflow {
       color: white;
       }
+      .relocation {
+      color: mediumpurple;
+      }
       a:link {
       color: aqua;
       background-color: transparent;
diff --git a/src/utils/sym.ml b/src/utils/sym.ml
index 42ef411d..83421beb 100644
--- a/src/utils/sym.ml
+++ b/src/utils/sym.ml
@@ -16,16 +16,18 @@ let max_addr = Z.(shift_left (of_int 1) 64 - (of_int 1))
 let min_addr = Z.of_int 0
 
 (* TODO very hacky *)
-let less x y = match (x, y) with
-| (Sym_ocaml.Num.Absolute x, Sym_ocaml.Num.Offset (_, y)) when Nat_big_num.less x y -> true
-| (Sym_ocaml.Num.Absolute x, Sym_ocaml.Num.Offset (_,_)) when Nat_big_num.greater_equal x max_addr -> false
-| (Sym_ocaml.Num.Offset (_,_), Sym_ocaml.Num.Absolute y) when Nat_big_num.less max_addr y -> true
-| (Sym_ocaml.Num.Offset (_, x), Sym_ocaml.Num.Absolute y) when Nat_big_num.greater_equal x y -> false
-| _ -> Sym_ocaml.Num.comp Nat_big_num.less x y
-let less_equal = Sym_ocaml.Num.less_equal
-let greater = Sym_ocaml.Num.greater
-let greater_equal = Sym_ocaml.Num.greater_equal
-let compare = Sym_ocaml.Num.compare
+let compare x y = match (x, y) with
+| (Sym_ocaml.Num.Absolute x, Sym_ocaml.Num.Offset (_, y)) when Nat_big_num.less x y -> -1
+| (Sym_ocaml.Num.Absolute x, Sym_ocaml.Num.Offset (_, _)) when Nat_big_num.greater_equal x max_addr -> 1
+| (Sym_ocaml.Num.Offset (_, x), Sym_ocaml.Num.Absolute y) when Nat_big_num.less y x -> 1 
+| (Sym_ocaml.Num.Offset (_, _), Sym_ocaml.Num.Absolute y) when Nat_big_num.greater_equal y max_addr -> -1
+| (x, y) -> Sym_ocaml.Num.compare x y
+
+let less x y = compare x y < 0
+let less_equal x y = compare x y <= 0
+(* let equal x y = compare x y = 0 *)
+let greater x y = compare x y > 0
+let greater_equal x y = compare x y >= 0
 
 let to_string = Sym_ocaml.Num.ppf Z.to_string
 
@@ -45,4 +47,16 @@ let in_range first last x = match (first, last, x) with
 | (Sym_ocaml.Num.Absolute f, Sym_ocaml.Num.Absolute l, Sym_ocaml.Num.Absolute x) -> Nat_big_num.less_equal f x && Nat_big_num.less_equal x l
 | (Sym_ocaml.Num.Offset (s1, f), Sym_ocaml.Num.Offset (s2, l), Sym_ocaml.Num.Offset (s, x)) when s1 = s2 ->
   s1 = s && Nat_big_num.less_equal f x && Nat_big_num.less_equal x l (* TODO kinda hacky *)
-| _ -> Raise.fail "Can't determine if %t is in range [%t,%t]" (Pp.tos pp x) (Pp.tos pp first) (Pp.tos pp last)
\ No newline at end of file
+| _ -> Raise.fail "Can't determine if %t is in range [%t,%t]" (Pp.tos pp x) (Pp.tos pp first) (Pp.tos pp last)
+
+module Ordered = struct
+  let compare x y = match (x, y) with
+  | (Sym_ocaml.Num.Offset (s1, _x), Sym_ocaml.Num.Offset (s2, _y)) when s1 <> s2 -> String.compare s1 s2
+  | (x, y) -> compare x y
+
+  let less_equal x y = compare x y <= 0
+  let less x y = compare x y < 0
+  let greater x y = compare x y > 0
+  let greater_equal x y = compare x y >= 0
+  let equal x y = compare x y = 0
+end
\ No newline at end of file

From 11557319a2044cf76b91a29303c3714cf2c69451 Mon Sep 17 00:00:00 2001
From: Peter Sewell <Peter.Sewell@cl.cam.ac.uk>
Date: Sat, 14 Jun 2025 10:49:08 +0100
Subject: [PATCH 090/116] fix syntax for parsing objdump with %-separated
 relocations

---
 src/analyse/ControlFlow.ml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 8eefb233..5089c761 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -451,10 +451,19 @@ AArch64:
    10004:	52800129 	mov	w9, #0x9                   	// #9
  *)
 
+(* matej version *)
+(*
 let relocation_regexp_string = "[ \t][0-9a-fA-F]+:[ \t]\\([0-9A-Z_]+\\)\t\\(.*\\)"
 
 let objdump_line_regexp =
   Str.regexp (" *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\)[ \t]*\\([^:]*\\)\\(" ^ relocation_regexp_string ^ "\\)?$")
+*)
+(* ps version *)
+
+let relocation_regexp_string = "%[ \t]+[0-9a-fA-F]+:[ \t]+\\([0-9A-Z_]+\\)[ \t]+\\(.*\\)"
+
+let objdump_line_regexp =
+  Str.regexp (" *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\)[ \t]*\\([^%]*\\)\\(" ^ relocation_regexp_string ^ "\\)?$")
 
 let section_start_line_regexp =
   Str.regexp "Disassembly of section \\(.*\\):$"

From 43d8f0a268f18b0ab712ff62462af6cc4a335a1b Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 9 Jul 2025 17:19:47 +0100
Subject: [PATCH 091/116] Fix loading files

---
 .gitignore           |  1 +
 src/analyse/Pp.ml    | 10 ----------
 src/analyse/Utils.ml | 10 ++++++++++
 src/run/funcRD.ml    | 13 ++++++-------
 src/run/relProg.ml   | 13 ++++++-------
 5 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/.gitignore b/.gitignore
index 765ac696..fdc3cedf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ _build/*
 **/.merlin
 test_asm/build
 .rdcache
+.vscode
diff --git a/src/analyse/Pp.ml b/src/analyse/Pp.ml
index cc57b5f6..354fb260 100644
--- a/src/analyse/Pp.ml
+++ b/src/analyse/Pp.ml
@@ -676,16 +676,6 @@ let chunks_of_ranged_cu m test an filename_stem ((low, high), cu) =
   (title, instructions_chunk :: chunks0)
 
 let wrap_body m (chunk_name, chunk_title, chunk_body) =
-  let read_html name =
-    let rec inter_p = function
-      | [] -> Error "not found"
-      | dir::dirs ->
-         let filename = Filename.concat dir name  in
-         if Sys.file_exists filename
-         then read_file_lines filename
-         else inter_p dirs
-    in inter_p (Htmlpaths.Sites.html)
-  in
   match m with
   | Ascii ->
       ( if chunk_name = "instructions" then
diff --git a/src/analyse/Utils.ml b/src/analyse/Utils.ml
index 5d79072b..b249f58d 100644
--- a/src/analyse/Utils.ml
+++ b/src/analyse/Utils.ml
@@ -119,3 +119,13 @@ let sys_command s =
   else
     let exit_code = Sys.command s in
     if exit_code <> 0 then fatal "sys_command %s failed with exit code %d" s exit_code else ()
+
+let read_html name =
+  let rec inter_p = function
+    | [] -> Error "not found"
+    | dir::dirs ->
+        let filename = Filename.concat dir name  in
+        if Sys.file_exists filename
+        then read_file_lines filename
+        else inter_p dirs
+  in inter_p (Htmlpaths.Sites.html)
\ No newline at end of file
diff --git a/src/run/funcRD.ml b/src/run/funcRD.ml
index 052b50b9..b2696435 100644
--- a/src/run/funcRD.ml
+++ b/src/run/funcRD.ml
@@ -56,10 +56,9 @@ open Logs.Logger (struct
 end)
 
 let run_func_rd elfname name objdump_d branchtables breakpoints =
-  match Analyse.Utils.read_file_lines "src/analyse/html-preamble-insts.html" with
-  | Error _ -> ()
-  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
-  ;
+  (match Analyse.Utils.read_html "html-preamble-insts.html" with
+  | Error _ -> err "Could not read html-preamble-insts.html"
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines);
   base "Running with rd %s in %s" name elfname;
   base "Loading %s" elfname;
   let dwarf = Dw.of_file elfname in
@@ -148,9 +147,9 @@ let run_func_rd elfname name objdump_d branchtables breakpoints =
                         base "At %t, %s:\n%t" Pp.(top Elf.Address.pp pc) msg Pp.(topi (State.pp_partial ~regs) st));
                  print_string (print_analyse_instruction pc)))
         runner.funcs; 
-  match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
-  | Error _ -> ()
-  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
+  (match Analyse.Utils.read_html "html-postamble.html" with
+  | Error _ -> err "Could not read html-postamble.html"
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines)
 
 let elf =
   let doc = "ELF file from which to pull the code" in
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index f4a0f354..1e83bd0d 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -140,10 +140,9 @@ let printvars ~st ~(dwarf: Dw.t) pc =
 
 
 let run_prog elfname name objdump_d branchtables =
-  match Analyse.Utils.read_file_lines "src/analyse/html-preamble-insts.html" with
-  | Error _ -> ()
-  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
-  ;
+  (match Analyse.Utils.read_html "html-preamble-insts.html" with
+  | Error _ -> err "Could not read html-preamble-insts.html"
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines);
   base "Running with rd %s in %s" name elfname;
   base "Loading %s" elfname;
   let dwarf = Dw.of_file elfname in
@@ -191,9 +190,9 @@ let run_prog elfname name objdump_d branchtables =
     List.iter iter succ
   in
   iter tree;
-  match Analyse.Utils.read_file_lines "src/analyse/html-postamble.html" with
-  | Error _ -> ()
-  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines
+  (match Analyse.Utils.read_html "html-postamble.html" with
+  | Error _ -> err "Could not read html-postamble.html"
+  | Ok lines -> Array.iter (function s -> Printf.printf "%s\n" s) lines)
 
 
 let elf =

From b5b27006f0e995df2690991fc122ae76b95563e2 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Wed, 9 Jul 2025 18:34:39 +0100
Subject: [PATCH 092/116] wip

---
 src/elf/address.ml   |  2 ++
 src/elf/file.ml      | 66 +++++++++++++++++++++++++++++++++++++++++++-
 src/elf/symTable.ml  | 19 +++++++++----
 src/elf/symTable.mli | 13 +++++----
 src/elf/symbol.ml    | 28 ++++++++++++++++---
 src/elf/symbol.mli   | 26 ++++++++++++-----
 6 files changed, 131 insertions(+), 23 deletions(-)

diff --git a/src/elf/address.ml b/src/elf/address.ml
index 33da9cd8..d22d48bb 100644
--- a/src/elf/address.ml
+++ b/src/elf/address.ml
@@ -3,6 +3,8 @@ type t = {
   offset: int;
 }
 
+let absolute x = { section = ""; offset = x }
+
 let pp addr = Pp.(!^(addr.section) ^^ !^"+" ^^ ptr addr.offset)
 
 let of_linksem (section, offset) = { section; offset = Z.to_int offset }
diff --git a/src/elf/file.ml b/src/elf/file.ml
index 095ad835..4bc5244f 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -137,7 +137,7 @@ let of_file (filename : string) =
   let entry = Z.to_int elf64_file.elf64_file_header.elf64_entry in
   let machine = machine_of_linksem elf64_file.elf64_file_header.elf64_machine in
   debug "Loading ELF symbols of %s" filename;
-  let symbols = SymTbl.of_linksem symbol_map in
+  let symbols = SymTbl.of_linksem_relocatable symbol_map in
   debug "Adding .rodata section of %s" filename;
   (* We add the .rodata section seperately from the symbols because
      - it can contain non-symbol information such as string literals and
@@ -189,3 +189,67 @@ let of_file (filename : string) =
   in
   info "ELF file %s has been loaded" filename;
   { filename; symbols; entry; machine; linksem = elf_file; rodata; sections }
+
+let of_executable_file (filename : string) =
+  info "Loading ELF file %s" filename;
+  (* parse the ELF file using linksem *)
+  let ( (elf_file : Elf_file.elf_file),
+        (elf_epi : Sail_interface.executable_process_image),
+        (symbol_map : Elf_file.global_symbol_init_info) ) =
+    match Sail_interface.populate_and_obtain_global_symbol_init_info filename with
+    | Error.Fail s -> elferror "Linksem: populate_and_obtain_global_symbol_init_info: %s" s
+    | Error.Success x -> x
+  in
+  (* Check this is a 64 bits ELF file *)
+  begin
+    match elf_file with
+    | Elf_file.ELF_File_32 _ -> elferror "32 bits elf files unsupported"
+    | _ -> ()
+  end;
+  let (segments, entry, machine) =
+    match elf_epi with
+    | ELF_Class_32 _ -> elferror "32 bits elf file class unsupported"
+    | ELF_Class_64 (s, e, m) -> (s, e, m)
+  in
+
+  (* Extract all the segments *)
+  let segments =
+    List.filter_map
+      (fun (seg, prov) -> if prov = Elf_file.FromELF then Some seg else None)
+      segments
+  in
+  let entry = Z.to_int entry in
+  let machine = machine_of_linksem machine in
+  debug "Loading ELF segments of %s" filename;
+  let segments = List.map Segment.of_linksem segments in
+  debug "Loaded ELF segments %t"
+  @@ Pp.top (Pp.list Pp.hex)
+  @@ List.map (fun x -> x.Segment.addr) segments;
+  debug "Loading ELF symbols of %s" filename;
+  let symbols = SymTbl.of_linksem_executable segments symbol_map in
+  debug "Adding .rodata section of %s" filename;
+  (* We add the .rodata section seperately from the symbols because
+     - it can contain non-symbol information such as string literals and
+       constants used in branch-register target calculations
+     - the range of the section is guaranteed to overlap with any symbols
+       within it, and so not suitable to be stored in the [RngMap] *)
+  (* TODO multiple rodata sections *)
+  let rodata =
+    let (_, addr, data) =
+      Dwarf.extract_section_body_without_relocations elf_file ".rodata" false
+      (* `false' argument is for returning an empty byte-sequence if
+         section is not found, instead of throwing an exception *)
+    in
+    Segment.
+      {
+        data=(data, Relocations.IMap.empty);
+        addr = Sym.to_int addr;
+        size = BytesSeq.length data;
+        read = true;
+        write = false;
+        execute = false;
+      }
+  in
+  info "ELF file %s has been loaded" filename;
+  (* TODO should we include the section info here as well? *)
+  { filename; symbols; entry; machine; linksem = elf_file; rodata=SMap.singleton ".rodata" rodata; sections = [] }
\ No newline at end of file
diff --git a/src/elf/symTable.ml b/src/elf/symTable.ml
index f0ac45a1..667d1052 100644
--- a/src/elf/symTable.ml
+++ b/src/elf/symTable.ml
@@ -52,8 +52,6 @@ open Symbol
 
 type sym = Symbol.t
 
-type linksem_sym = Symbol.linksem_t
-
 type sym_offset = sym * int
 
 module RMap = RngMap.Make (Symbol)
@@ -97,7 +95,10 @@ module AddrMap = struct
   
 end
 
-type linksem_t = LinksemRelocatable.global_symbol_init_info
+type linksem_relocatable_t = LinksemRelocatable.global_symbol_init_info
+
+type linksem_executable_t = Elf_file.global_symbol_init_info
+
 
 type t = { by_name : sym SMap.t; by_addr : AddrMap.t }
 
@@ -150,12 +151,18 @@ let of_position_string t s : sym_offset =
   if s.[0] = '0' then raise Not_found (* no absolute addresses *)
   else sym_offset_of_string t s
 
-let of_linksem linksem_map =
-  let add_linksem_sym_to_map (map : t) (lsym : linksem_sym) =
-    if is_interesting_linksem lsym then add map (Symbol.of_linksem lsym) else map
+let of_linksem_generic get_typ of_linksem linksem_map =
+  let add_linksem_sym_to_map (map : t) lsym =
+    if is_interesting_linksem get_typ lsym then add map (of_linksem lsym) else map
   in
   List.fold_left add_linksem_sym_to_map empty linksem_map
 
+let of_linksem_relocatable =
+  of_linksem_generic linksem_relocatable_typ of_linksem_relocatable
+
+let of_linksem_executable segments =
+  of_linksem_generic linksem_executable_typ (of_linksem_executable segments)
+
 let pp_raw st = AddrMap.bindings st.by_addr |> List.map (Pair.map Address.pp pp_raw) |> Pp.mapping "syms"
 
 let iter t f = SMap.iter (fun _ value -> f value) t.by_name
diff --git a/src/elf/symTable.mli b/src/elf/symTable.mli
index 18e7de50..ebf1256b 100644
--- a/src/elf/symTable.mli
+++ b/src/elf/symTable.mli
@@ -52,12 +52,12 @@
 
 type sym = Symbol.t
 
-type linksem_sym = Symbol.linksem_t
-
 (** The type of a symbol with offset *)
 type sym_offset = sym * int
 
-type linksem_t = LinksemRelocatable.global_symbol_init_info
+type linksem_relocatable_t = LinksemRelocatable.global_symbol_init_info
+
+type linksem_executable_t = Elf_file.global_symbol_init_info
 
 (** The type of a symbol table. *)
 type t
@@ -107,10 +107,13 @@ val sym_offset_of_string : t -> string -> sym_offset
 *)
 val of_position_string : t -> string -> sym_offset
 
-(** Extract the symbol from the linksem symbol representation.
+(** Extract the symbol from the linksem symbol representation (relocatable file). *)
+val of_linksem_relocatable : linksem_relocatable_t -> t
+
+(** Extract the symbol from the linksem symbol representation (executable file).
 
     Need the segments for filling the missing symbol data *)
-val of_linksem : linksem_t -> t
+val of_linksem_executable : Segment.t list -> linksem_executable_t -> t
 
 (** Pretty print the table as a raw ocaml value *)
 val pp_raw : t -> Pp.document
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 263c184b..8e4024d2 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -68,7 +68,9 @@ type t = {
   data : data;
 }
 
-type linksem_t = LinksemRelocatable.symbol
+type linksem_relocatable_t = LinksemRelocatable.symbol
+
+type linksem_executable_t = string * (Z.t * Z.t * Z.t * BytesSeq.t option * Z.t)
 
 let push_name s t = { t with other_names = s :: t.other_names }
 
@@ -85,7 +87,9 @@ let typ_of_linksem ltyp =
   | 4 -> FILE
   | _ -> UNKNOWN
 
-let linksem_typ (_name, (typ, _size, _addr, _data, _), _) = typ
+let linksem_relocatable_typ (_name, (typ, _size, _addr, _data, _), _) = typ
+
+let linksem_executable_typ (_name, (typ, _size, _addr, _data, _)) = typ
 
 (** [LoadingError(name,addr)] means that symbol [name] at [addr] could not be loaded *)
 exception LoadingError of string * int
@@ -100,7 +104,7 @@ let _ =
 (* module SMap = Map.Make (String)
 let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000 *)
 
-let of_linksem (name, (typ, size, addr, (data, rels), _), writable) =
+let of_linksem_relocatable (name, (typ, size, addr, (data, rels), _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
   let addr = Address.of_linksem addr in
@@ -108,9 +112,25 @@ let of_linksem (name, (typ, size, addr, (data, rels), _), writable) =
   (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
 
+let of_linksem_executable segs (name, (typ, size, addr, data, _)) =
+  let typ = typ_of_linksem typ in
+  let size = Z.to_int size in
+  let addr = Z.to_int addr in
+  let segment =
+    Option.value_fail (Segment.get_containing segs addr) "No segment contains symbol %s" name
+  in
+  let writable = segment.write in
+  let data =
+    data
+    |> Option.value_fun ~default:(fun () ->
+      (* TODO use some wrapper for byte sequences with relocations *)
+      Segment.get_addr (fun (bs, _) -> BytesSeq.getbs ~len:size bs) segment addr)
+  in
+  { name; other_names = []; typ; size; addr=Address.absolute addr; data={data; relocations=Relocations.IMap.empty}; writable }
+
 let is_interesting = function OBJECT | FUNC -> true | _ -> false
 
-let is_interesting_linksem lsym = lsym |> linksem_typ |> typ_of_linksem |> is_interesting
+let is_interesting_linksem get_typ lsym = lsym |> get_typ |> typ_of_linksem |> is_interesting
 
 let sub sym off len = {
   data = BytesSeq.sub sym.data.data off len;
diff --git a/src/elf/symbol.mli b/src/elf/symbol.mli
index 3bc5803f..7ed2b952 100644
--- a/src/elf/symbol.mli
+++ b/src/elf/symbol.mli
@@ -73,8 +73,11 @@ type t = {
   data : data;
 }
 
-(** The type of an ELF symbol in linksem. See {!of_linksem}*)
-type linksem_t = LinksemRelocatable.symbol
+(** The type of an ELF symbol in linksem (relocatable file). See {!of_linksem_relocatable}*)
+type linksem_relocatable_t = LinksemRelocatable.symbol
+
+(** The type of an ELF symbol in linksem (executable file). See {!of_linksem_executable}*)
+type linksem_executable_t = string * (Z.t * Z.t * Z.t * BytesSeq.t option * Z.t)
 
 (** Add a name to the other names list *)
 val push_name : string -> t -> t
@@ -88,24 +91,33 @@ val len : t -> int
 (** Convert the integer type into typ *)
 val typ_of_linksem : linksem_typ -> typ
 
-(** Get the type from the linksem symbol type *)
-val linksem_typ : linksem_t -> linksem_typ
+(** Get the type from the linksem symbol type (relocatable file) *)
+val linksem_relocatable_typ : linksem_relocatable_t -> linksem_typ
+
+(** Get the type from the linksem symbol type (executable file) *)
+val linksem_executable_typ : linksem_executable_t -> linksem_typ
 
 (** [LoadingError(name,addr)] means that symbol [name] at [addr] could not be loaded.*)
 exception LoadingError of string * int
 
-(** Convert a symbol from linksem to read-dwarf representation using the segment data
+(** Convert a symbol from linksem to read-dwarf representation (relocatable file).
+
+    May raise {!LoadingError} when the symbol has no data
+*)
+val of_linksem_relocatable : linksem_relocatable_t -> t
+
+(** Convert a symbol from linksem to read-dwarf representation using the segment data (executable file).
 
     May raise {!LoadingError} when the symbol has no data and the
     data cannot be found in the segments
 *)
-val of_linksem : linksem_t -> t
+val of_linksem_executable : Segment.t list -> linksem_executable_t -> t
 
 (** Tell if a symbol type is interesting for readDwarf purposes *)
 val is_interesting : typ -> bool
 
 (** Tell if a linksem symbol is interesting for readDwarf purposes *)
-val is_interesting_linksem : linksem_t -> bool
+val is_interesting_linksem : ('a -> linksem_typ) -> 'a -> bool
 
 (** Take the BytesSeq.t corresponding to the offset and length *)
 val sub : t -> int -> int -> data

From ab8fb0234b2f9ba3708d08da86762a91c93ab81d Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Jul 2025 18:59:09 +0100
Subject: [PATCH 093/116] Parse both executable and relocatable files

---
 src/dw/addr.ml  |  2 +-
 src/elf/file.ml | 42 ++++++++++++++++++++++++++----------------
 2 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/dw/addr.ml b/src/dw/addr.ml
index 201906bf..ded896e3 100644
--- a/src/dw/addr.ml
+++ b/src/dw/addr.ml
@@ -2,5 +2,5 @@ include Elf.Address
 
 let of_sym : Sym.t -> t = function
 | Sym_ocaml.Num.Offset (section, offset) -> { section; offset = Z.to_int offset }
-| _ -> Raise.fail "expected section+offset"
+| Sym_ocaml.Num.Absolute z -> absolute (Z.to_int z)
 
diff --git a/src/elf/file.ml b/src/elf/file.ml
index 4bc5244f..bafd91d0 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -107,21 +107,7 @@ let _ =
 (** Throw an {!ElfError} *)
 let elferror fmt = Printf.ksprintf (fun s -> raise (ElfError s)) fmt
 
-(** Parse an ELF file to create an {!Elf.File.t} using Linksem.
-
-    May raise an {!ElfError}
-*)
-let of_file (filename : string) =
-  info "Loading ELF file %s" filename;
-  (* parse the ELF file using linksem *)
-  let bs = match Byte_sequence.acquire filename with
-    | Error.Fail s -> elferror "Linksem: Byte_sequence.acquire: %s" s
-    | Error.Success x -> x
-  in
-  let elf64_file = match Elf_file.read_elf64_file bs with
-    | Error.Fail s -> elferror "Linksem: read_elf64_file: %s" s
-    | Error.Success x -> x
-  in
+let of_relocatable_file (filename : string) elf64_file =
   let symbol_map = match LinksemRelocatable.get_elf64_file_global_symbol_init elf64_file with
     | Error.Fail s -> elferror "LinksemRelocatable: get_elf64_file_global_symbol_init: %s" s
     | Error.Success x -> x
@@ -252,4 +238,28 @@ let of_executable_file (filename : string) =
   in
   info "ELF file %s has been loaded" filename;
   (* TODO should we include the section info here as well? *)
-  { filename; symbols; entry; machine; linksem = elf_file; rodata=SMap.singleton ".rodata" rodata; sections = [] }
\ No newline at end of file
+  { filename; symbols; entry; machine; linksem = elf_file; rodata=SMap.singleton ".rodata" rodata; sections = [] }
+
+
+(** Parse an ELF file to create an {!Elf.File.t} using Linksem.
+
+    May raise an {!ElfError}
+*)
+let of_file (filename : string) =
+  info "Loading ELF file %s" filename;
+  (* parse the ELF file using linksem *)
+  let bs = match Byte_sequence.acquire filename with
+    | Error.Fail s -> elferror "Linksem: Byte_sequence.acquire: %s" s
+    | Error.Success x -> x
+  in
+  let elf64_file = match Elf_file.read_elf64_file bs with
+    | Error.Fail s -> elferror "Linksem: read_elf64_file: %s" s
+    | Error.Success x -> x
+  in
+  if Elf_header.is_elf64_relocatable_file elf64_file.elf64_file_header then
+    of_relocatable_file filename elf64_file
+  else if Elf_header.is_elf64_executable_file elf64_file.elf64_file_header then
+    (* TODO currently this loads the file twice *)
+    of_executable_file filename
+  else
+    elferror "Linksem: of_file: not an ELF64 relocatable or executable file: %s" filename
\ No newline at end of file

From a69e2d0a7c7a0588f510b09917346cb095dffbb2 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Jul 2025 19:47:57 +0100
Subject: [PATCH 094/116] Allow both absolute and section-relative addresses
 (wip)

the executor still expects pc values to be section-relative
---
 src/ctype/ctype.ml            |  1 +
 src/dw/addr.ml                |  2 +-
 src/elf/address.ml            | 13 ++++++++-----
 src/elf/linksemRelocatable.ml |  2 +-
 src/elf/symTable.ml           | 24 ++++++++++++++----------
 src/elf/symbol.ml             |  2 +-
 src/run/func.ml               |  2 +-
 src/run/relProg.ml            |  2 +-
 src/run/testRelProg.ml        |  4 ++--
 src/state/base.ml             | 29 ++++++++++++++++++-----------
 src/trace/typer.ml            |  2 +-
 11 files changed, 49 insertions(+), 34 deletions(-)

diff --git a/src/ctype/ctype.ml b/src/ctype/ctype.ml
index dbbe61f8..cb97ab46 100644
--- a/src/ctype/ctype.ml
+++ b/src/ctype/ctype.ml
@@ -137,6 +137,7 @@ and fragment =
   | Single of t  (** Single object: Only when accessing of a global variable *)
   | DynArray of t  (** Generic C pointer, may point to multiple element of that type *)
   | DynFragment of int  (** Writable fragment for memory whose type is changing dynamically *)
+  (* TODO broken - maybe shouldn't have the section string *)
   | Global of string
       (** The Global fragment that contains all the fixed ELF section
                .text, .data, .rodata, ... *)
diff --git a/src/dw/addr.ml b/src/dw/addr.ml
index ded896e3..8b3e0b55 100644
--- a/src/dw/addr.ml
+++ b/src/dw/addr.ml
@@ -1,6 +1,6 @@
 include Elf.Address
 
 let of_sym : Sym.t -> t = function
-| Sym_ocaml.Num.Offset (section, offset) -> { section; offset = Z.to_int offset }
+| Sym_ocaml.Num.Offset (section, offset) -> { section = Some section; offset = Z.to_int offset }
 | Sym_ocaml.Num.Absolute z -> absolute (Z.to_int z)
 
diff --git a/src/elf/address.ml b/src/elf/address.ml
index d22d48bb..17e7ce1d 100644
--- a/src/elf/address.ml
+++ b/src/elf/address.ml
@@ -1,13 +1,13 @@
 type t = {
-  section : string;
+  section : string option;
   offset: int;
 }
 
-let absolute x = { section = ""; offset = x }
+let absolute x = { section = None; offset = x }
 
-let pp addr = Pp.(!^(addr.section) ^^ !^"+" ^^ ptr addr.offset)
+let pp addr = Pp.(optional (fun s -> !^s ^^ !^"+") addr.section ^^ ptr addr.offset)
 
-let of_linksem (section, offset) = { section; offset = Z.to_int offset }
+let of_linksem_relocatable (section, offset) = { section = Some section; offset = Z.to_int offset }
 
 let (+) addr offset = { section = addr.section; offset = addr.offset + offset }
 
@@ -25,4 +25,7 @@ let (<=) = compare (<=)
 
 let (>=) = compare (>=)
 
-let to_sym {section; offset} = Sym_ocaml.Num.Offset (section, Z.of_int offset)
\ No newline at end of file
+let to_sym {section; offset} = 
+  match section with
+  | Some s -> Sym_ocaml.Num.Offset (s, Z.of_int offset)
+  | None -> Sym_ocaml.Num.Absolute (Z.of_int offset)
\ No newline at end of file
diff --git a/src/elf/linksemRelocatable.ml b/src/elf/linksemRelocatable.ml
index 5f92e2e0..9a3d2aab 100644
--- a/src/elf/linksemRelocatable.ml
+++ b/src/elf/linksemRelocatable.ml
@@ -1,4 +1,4 @@
-(* TODO header *)
+(* TODO move to linksem? *)
 
 module SMap = Map.Make (String)
 
diff --git a/src/elf/symTable.ml b/src/elf/symTable.ml
index 667d1052..095cee81 100644
--- a/src/elf/symTable.ml
+++ b/src/elf/symTable.ml
@@ -56,12 +56,16 @@ type sym_offset = sym * int
 
 module RMap = RngMap.Make (Symbol)
 module SMap = Map.Make (String)
+module OSMap = Map.Make (struct
+  type t = string option
+  let compare = Option.compare String.compare
+end)
 
 module AddrMap = struct
-  type t = RMap.t SMap.t
+  type t = RMap.t OSMap.t
 
   let add t (addr: Address.t) sym =
-    SMap.update addr.section (fun old ->
+    OSMap.update addr.section (fun old ->
       let old = match old with
       | None -> RMap.empty
       | Some x -> x
@@ -70,24 +74,24 @@ module AddrMap = struct
     ) t
   
   let update f t (addr: Address.t) =
-    SMap.update addr.section (Option.map (fun x -> RMap.update f x addr.offset)) t
+    OSMap.update addr.section (Option.map (fun x -> RMap.update f x addr.offset)) t
   
-  let empty = SMap.empty
+  let empty = OSMap.empty
 
   let at t (addr: Address.t) =
-    SMap.find addr.section t |> Fun.flip RMap.at addr.offset
+    OSMap.find addr.section t |> Fun.flip RMap.at addr.offset
 
   let at_opt t (addr: Address.t) =
-    Option.bind (SMap.find_opt addr.section t) @@ Fun.flip RMap.at_opt addr.offset
+    Option.bind (OSMap.find_opt addr.section t) @@ Fun.flip RMap.at_opt addr.offset
   
   let at_off t (addr: Address.t) =
-    SMap.find addr.section t |> Fun.flip RMap.at_off addr.offset
+    OSMap.find addr.section t |> Fun.flip RMap.at_off addr.offset
   
   let at_off_opt t (addr: Address.t) =
-    Option.bind (SMap.find_opt addr.section t) @@ Fun.flip RMap.at_off_opt addr.offset
+    Option.bind (OSMap.find_opt addr.section t) @@ Fun.flip RMap.at_off_opt addr.offset
   
   let bindings t =
-    let sections = SMap.bindings t in
+    let sections = OSMap.bindings t in
     List.bind sections @@ fun (section, rmap) ->
       let inner_bindings = RMap.bindings rmap in
       List.map (fun (offset, sym) -> (Address.{section; offset}, sym)) inner_bindings
@@ -148,7 +152,7 @@ let sym_offset_of_string t s : sym_offset =
 let of_position_string t s : sym_offset =
   let s = String.trim s in
   if s = "" then raise Not_found;
-  if s.[0] = '0' then raise Not_found (* no absolute addresses *)
+  if s.[0] = '0' then raise Not_found (* no absolute addresses *) (* TODO handle absolute addresses *)
   else sym_offset_of_string t s
 
 let of_linksem_generic get_typ of_linksem linksem_map =
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 8e4024d2..0e66a393 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -107,7 +107,7 @@ let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.
 let of_linksem_relocatable (name, (typ, size, addr, (data, rels), _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
-  let addr = Address.of_linksem addr in
+  let addr = Address.of_linksem_relocatable addr in
   let data = { data; relocations = Relocations.of_linksem rels } in
   (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
diff --git a/src/run/func.ml b/src/run/func.ml
index 08ac6c2b..20fc555f 100644
--- a/src/run/func.ml
+++ b/src/run/func.ml
@@ -80,7 +80,7 @@ let get_state_tree ~elf:elfname ~name ?(dump = false) ?(entry = false) ?len ?(br
         List.map
           (fun x ->
             if String.starts_with ~prefix:"UND" x then (*HACK for undefined symbol*)
-              Elf.Address.{ section=x; offset=0 }
+              Elf.Address.{ section=Some x; offset=0 }
             else
               x |> Elf.SymTable.of_position_string elf.symbols |> Elf.SymTable.to_addr_offset
           )
diff --git a/src/run/relProg.ml b/src/run/relProg.ml
index 1e83bd0d..cb92df2d 100644
--- a/src/run/relProg.ml
+++ b/src/run/relProg.ml
@@ -85,7 +85,7 @@ let eval_loc ?frame_value sz st (loc: Dw.Loc.t) : State.Exp.t option =
   | Const x ->
       Some (match x with
       | Absolute x -> x |> BitVec.of_z ~size:(8*sz) |> Exp.Typed.bits
-      | Offset (s, o) -> State.Exp.of_address ~size:(8*sz) Elf.Address.{section=s; offset=Z.to_int o}
+      | Offset (s, o) -> State.Exp.of_address ~size:(8*sz) Elf.Address.{section=Some s; offset=Z.to_int o}
       )
   | Dwarf _ops -> None
 
diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
index e9f15408..412cde29 100644
--- a/src/run/testRelProg.ml
+++ b/src/run/testRelProg.ml
@@ -36,12 +36,12 @@ let rec process_tree ~pc ~ret ~ext (node:Block_lib.label State.Tree.t) =
       in
       let ret_exp = match pc_addr with
       | Some pc_addr ->
-        if pc_addr = Elf.Address.{ section="UND.abort"; offset=0 } then
+        if pc_addr = Elf.Address.{ section=Some "UND.abort"; offset=0 } then
           Result.error {
             msg=Printf.sprintf "abort called from %t" (Pp.tos Elf.Address.pp st.last_pc);
             asserts=st.asserts;
           }
-        else if pc_addr <> Elf.Address.{ section="UND.exit"; offset=0 } then
+        else if pc_addr <> Elf.Address.{ section=Some "UND.exit"; offset=0 } then
           Result.error {
             msg=Printf.sprintf "finished at weird address %t" (Pp.tos Elf.Address.pp pc_addr);
             asserts=st.asserts;
diff --git a/src/state/base.ml b/src/state/base.ml
index 17659776..2a1317d1 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -189,7 +189,7 @@ module Exp = struct
     | _ -> Raise.fail "Expected symbolic Section base"
     in
     let offset = BitVec.to_int conc in
-    Elf.Address.{ section; offset }
+    Elf.Address.{ section = Some section; offset }
   
   let of_section ~(size : int) (section : string) =
     Typed.extract ~last:(size-1) ~first:0
@@ -198,9 +198,10 @@ module Exp = struct
 
   let of_address ~(size : int) (addr : Elf.Address.t) =
     Typed.(
-      of_section ~size addr.section
-      +
-      bits_int ~size addr.offset
+      let offset = bits_int ~size addr.offset in
+      match addr.section with
+      | Some section -> of_section ~size section + offset
+      | None -> offset
     )
 end
 
@@ -433,8 +434,8 @@ module Mem = struct
       prov
   
   let get_section_provenance mem section =
-    Hashtbl.find_opt mem.sections section
-    |> Option.value ~default:Ctype.Main
+    let maybe_prov = Option.bind section (Hashtbl.find_opt mem.sections) in
+    Option.value maybe_prov ~default:Ctype.Main
 end
 
 type t = {
@@ -491,7 +492,7 @@ let make ?elf () =
       mem = Mem.empty ();
       elf;
       fenv = Fragment.Env.make ();
-      last_pc = Elf.Address.{ section = ".text"; offset = 0 }; (* TODO is this right? *)
+      last_pc = Elf.Address.{ section = Some ".text"; offset = 0 }; (* TODO is this right? *)
     }
   in
   next_id := id + 1;
@@ -576,13 +577,16 @@ let eval_address (s : t) (addr: Exp.t) : Elf.Address.t option =
     ConcreteEval.Symbolic -> None
   in
   let offset = offset_exp |> Value.expect_bv |> BitVec.to_int in
+  if ConcreteEval.is_concrete addr then
+    some @@ Elf.Address.absolute offset
+  else
   let sections = Hashtbl.create 10 in
   Ast.Manip.exp_iter_var (function Var.Section s -> Hashtbl.add sections s () | _ -> ()) addr;
 
   let hyps = load_relocation_asserts s in
   let size = addr |> Typed.get_type |> Typed.expect_bv in
   sections |> Hashtbl.to_seq_keys |> Seq.find_map (fun section ->
-    let address = Elf.Address.{ section; offset } in
+    let address = Elf.Address.{ section = Some section; offset } in
     let expression = Exp.of_address ~size address in
     if Z3St.check_full ~hyps Typed.(expression = addr) = Some true then
       Some address
@@ -612,7 +616,9 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
       with Not_found ->
         let int_addr = sym_addr.offset in
         let open Option in
-        let* rodata = Elf.File.SMap.find_opt sym_addr.section elf.rodata in
+        (* TODO handle multiple rodata sections/segments in executable files *)
+        let rodata_section = Option.value sym_addr.section ~default:".rodata" in
+        let* rodata = Elf.File.SMap.find_opt rodata_section elf.rodata in
         if rodata.addr <= int_addr && int_addr + size <= rodata.addr + rodata.size then
           let data, relocations = rodata.data in
           let data = BytesSeq.sub data (int_addr - rodata.addr) size in
@@ -709,8 +715,9 @@ let set_pc ~(pc : Reg.t) (s : t) (pcval : int) =
   let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
 
+(* TODO name is misleading *)
 let set_pc_sym ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
-  let exp = Typed.(var ~typ:(Ty_BitVec 64) (Var.Section pcval.section) + bits_int ~size:64 pcval.offset) in
+  let exp = Exp.of_address ~size:64 pcval in
   let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval.offset ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
   
@@ -805,7 +812,7 @@ let init_sections_symbolic ~sp ~addr_size state =
     push_section_constraints ~sp ~addr_size state elf.sections;
     Elf.SymTable.iter elf.symbols @@ fun sym ->
       if sym.typ = Elf.Symbol.OBJECT then
-        Hashtbl.replace state.mem.sections sym.addr.section Main
+        Option.iter (fun s -> Hashtbl.replace state.mem.sections s Main) sym.addr.section
   ) in
   lock state;
   state
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index 2dd8e1a2..d8b8c664 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -300,7 +300,7 @@ let fragment_at ~(dwarf : Dw.t) ~fenv ~size (frag : Ctype.fragment) at : Ctype.t
       let* (typ, off) = Fragment.at_off_opt frag at in
       Ctype.type_at ~env ~size typ off
   | Global s -> (
-      match Elf.SymTable.of_addr_with_offset_opt dwarf.elf.symbols Elf.Address.{ section = s; offset = at } with
+      match Elf.SymTable.of_addr_with_offset_opt dwarf.elf.symbols Elf.Address.{ section = Some s; offset = at } with
       | Some (sym, offset) -> (
           match Hashtbl.find_opt dwarf.vars sym.name with
           | Some v -> Ctype.type_at ~env ~size v.ctype offset

From c10e465e239dab76132e753eab4dba9361a96c2e Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 10 Jul 2025 20:11:55 +0100
Subject: [PATCH 095/116] Executor: accept absolute pc address

---
 src/run/block_lib.ml   | 10 +++++-----
 src/run/runner.ml      |  4 ++--
 src/run/testRelProg.ml |  2 +-
 src/state/base.ml      | 24 +++++++++---------------
 src/state/base.mli     |  6 ++----
 5 files changed, 19 insertions(+), 27 deletions(-)

diff --git a/src/run/block_lib.ml b/src/run/block_lib.ml
index 3b62215f..3da4b3e7 100644
--- a/src/run/block_lib.ml
+++ b/src/run/block_lib.ml
@@ -108,7 +108,7 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
             State.lock state
           end;
           let states =
-            let pc = State.Exp.expect_sym_address pc_exp in
+            let pc = State.Exp.expect_address pc_exp in
             if Option.fold ~none:true ~some:(Fun.flip Hashtbl.mem pc) relevant then (
               info "Running pc %t" (Pp.top State.Exp.pp pc_exp);
               Runner.run ~prelock:ignore b.runner state
@@ -124,11 +124,11 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
           | [state] when not every_instruction -> run_from state
           | [nstate] when every_instruction ->
               let rest = [run_from nstate] in
-              { state; data = NormalAt (State.Exp.expect_sym_address pc_exp); rest }
+              { state; data = NormalAt (State.Exp.expect_address pc_exp); rest }
           | states ->
               let rest = List.map run_from states in
               State.Tree.
-                { state; data = BranchAt (State.Exp.expect_sym_address pc_exp); rest }
+                { state; data = BranchAt (State.Exp.expect_address pc_exp); rest }
         )
     else begin
       info "Reached dead code at %t" (Pp.top State.Exp.pp pc_exp);
@@ -138,7 +138,7 @@ let run ?(every_instruction = false) ?relevant (b : t) (start : State.t) : label
     end
   in
   let state = State.copy start in
-  State.set_pc_sym ~pc:pcreg state b.start;
+  State.set_pc ~pc:pcreg state b.start;
   let rest = [run_from state] in
   State.Tree.{ state = start; data = Start; rest }
 
@@ -161,7 +161,7 @@ let gen_endpred ?min ?max ?loop ?(brks = []) () : State.exp -> string option =
   in
   fun pc_exp ->
     ( try
-      Some (State.Exp.expect_sym_address pc_exp)
+      Some (State.Exp.expect_address pc_exp)
     with
       _ -> None
     ) |> Option.map (fun pc ->
diff --git a/src/run/runner.ml b/src/run/runner.ml
index 7ae5ff59..8f311eec 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -191,7 +191,7 @@ let execute_normal ?(prelock = ignore) ~pc runner (instr : Trace.Instr.t) state
 let skip runner state : State.t list =
   let pc_exp = State.get_reg_exp state runner.pc in
   try
-    let pc = State.Exp.expect_sym_address pc_exp in
+    let pc = State.Exp.expect_address pc_exp in
     match fetch runner pc with
     | Normal { traces = _; read = _; written = _; length; opcode = _; relocation = _ }
      |Special length
@@ -223,7 +223,7 @@ let skip runner state : State.t list =
 let run ?prelock runner state : State.t list =
   let pc_exp = State.get_reg_exp state runner.pc in
   try
-    let pc = State.Exp.expect_sym_address pc_exp in
+    let pc = State.Exp.expect_address pc_exp in
     match fetch runner pc with
     | Normal instr -> execute_normal ?prelock ~pc runner instr state
     | Special _ ->
diff --git a/src/run/testRelProg.ml b/src/run/testRelProg.ml
index 412cde29..d520e9e7 100644
--- a/src/run/testRelProg.ml
+++ b/src/run/testRelProg.ml
@@ -30,7 +30,7 @@ let rec process_tree ~pc ~ret ~ext (node:Block_lib.label State.Tree.t) =
   | Block_lib.End _ -> let result = (
       let pc_exp = State.get_reg_exp st pc in
       let pc_addr = try
-        Some (State.Exp.expect_sym_address pc_exp)
+        Some (State.Exp.expect_address pc_exp)
       with
         _ -> None
       in
diff --git a/src/state/base.ml b/src/state/base.ml
index 2a1317d1..fb4381fa 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -182,14 +182,15 @@ module Exp = struct
 
   let of_reg id reg = Var.of_reg id reg |> of_var
 
-  let expect_sym_address exp =
+  let expect_address exp =
     let sym, conc = Exp.Sums.split_concrete exp in
     let section = match sym with
-    | Some(Ast.Var (Var.Section s, _)) -> s
-    | _ -> Raise.fail "Expected symbolic Section base"
+    | Some(Ast.Var (Var.Section s, _)) -> Some s
+    | None -> None
+    | Some e -> Raise.fail "Address %t contains symbolic subexpression: %t" (Pp.tos pp exp) (Pp.tos pp e)
     in
     let offset = BitVec.to_int conc in
-    Elf.Address.{ section = Some section; offset }
+    Elf.Address.{ section = section; offset }
   
   let of_section ~(size : int) (section : string) =
     Typed.extract ~last:(size-1) ~first:0
@@ -709,14 +710,7 @@ let get_reg_exp s reg = get_reg s reg |> Tval.exp
 let update_reg_exp (s : t) (reg : Reg.t) (f : exp -> exp) =
   Reg.Map.get s.regs reg |> Tval.map_exp f |> Reg.Map.set s.regs reg
 
-(* TODO *)
-let set_pc ~(pc : Reg.t) (s : t) (pcval : int) =
-  let exp = Typed.bits_int ~size:64 pcval in
-  let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval ~constexpr:true in
-  set_reg s pc @@ Tval.make ~ctyp exp
-
-(* TODO name is misleading *)
-let set_pc_sym ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
+let set_pc ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
   let exp = Exp.of_address ~size:64 pcval in
   let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval.offset ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
@@ -724,12 +718,12 @@ let set_pc_sym ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
 
 let bump_pc ~(pc : Reg.t) (s : t) (bump : int) =
   let pc_exp = get_reg_exp s pc in
-  let old_pc = Exp.expect_sym_address pc_exp in
+  let old_pc = Exp.expect_address pc_exp in
   let new_pc = Elf.Address.(old_pc + bump) in
-  set_pc_sym ~pc s new_pc
+  set_pc ~pc s new_pc
 
 let concretize_pc ~(pc : Reg.t) (s : t) =
-  pc |> get_reg_exp s |> eval_address s |> Option.iter (set_pc_sym ~pc s)
+  pc |> get_reg_exp s |> eval_address s |> Option.iter (set_pc ~pc s)
 
 let set_last_pc state pc =
   assert (not @@ is_locked state);
diff --git a/src/state/base.mli b/src/state/base.mli
index 73d6c370..696fe923 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -162,7 +162,7 @@ module Exp : sig
   (** Create an expression from an register and a state id *)
   val of_reg : id -> Reg.t -> t
 
-  val expect_sym_address : t -> Elf.Address.t
+  val expect_address : t -> Elf.Address.t
 
   val of_section : size:int -> string -> t
 
@@ -498,9 +498,7 @@ val update_reg_exp : t -> Reg.t -> (exp -> exp) -> unit
 (** {1 Pc manipulation } *)
 
 (** Set the PC to a concrete value and keep its type appropriate *)
-val set_pc : pc:Reg.t -> t -> int -> unit
-
-val set_pc_sym : pc:Reg.t -> t -> Elf.Address.t -> unit
+val set_pc : pc:Reg.t -> t -> Elf.Address.t -> unit
 
 (** Bump a concrete PC by a concrete bump (generally the size of a non-branching instruction *)
 val bump_pc : pc:Reg.t -> t -> int -> unit

From 1cafb80388193ea9b075e09c8f2115d89f778424 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 20 Jul 2025 13:42:19 +0200
Subject: [PATCH 096/116] remove old todos

---
 src/trace/context.ml | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/trace/context.ml b/src/trace/context.ml
index 59950dc2..3b484435 100644
--- a/src/trace/context.ml
+++ b/src/trace/context.ml
@@ -96,9 +96,8 @@ let expand_var ~(ctxt : t) (v : Base.Var.t) (a : Ast.no Ast.ty) : State.exp =
       Fun.tee (HashVector.add ctxt.nondets i) (State.Var.new_nondet sz)
     )
     |> State.Exp.of_var
-  | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp (* TODO is the NonDet case correct *)
-  | Segment (name, _) -> SMap.find name ctxt.segments (*TODO put the actual value there*)
-  (* | Segment (name, sz) -> Exp.Typed.extract ~first:0 ~last:(sz-1) (State.Exp.of_var (State.Var.Section name)) TODO put the actual value there *)
+  | Read (i, _) -> (HashVector.get ctxt.mem_reads i).exp
+  | Segment (name, _) -> SMap.find name ctxt.segments
 
 (** Tell if typing should enabled with this context *)
 let typing_enabled ~(ctxt : t) = ctxt.dwarf <> None

From 6a6fee937be75ea5d3c36bcf83c0a91d1713beb5 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 20 Jul 2025 17:30:14 +0200
Subject: [PATCH 097/116] Enable run-instr

---
 src/run/instr.ml | 33 +++++++++++++++++++++------------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/src/run/instr.ml b/src/run/instr.ml
index 0098d35b..07c15d78 100644
--- a/src/run/instr.ml
+++ b/src/run/instr.ml
@@ -74,7 +74,7 @@ open Logs.Logger (struct
   let str = __MODULE__
 end)
 
-type traces = IslaTraces of Isla.rtrc list | Traces of Trace.t list
+type traces = IslaTraces of Isla.rtrc list | Traces of Elf.Relocations.rel option * Trace.t list
 
 let instr =
   let doc = "Instruction to run(either directly on in sym+offset way. See --elf" in
@@ -123,7 +123,7 @@ let elf =
   in
   Arg.(value & opt (some non_dir_file) None & info ["e"; "elf"] ~doc)
 
-let get_instr arch instr elfopt : BytesSeq.t =
+let get_instr arch instr elfopt : Elf.Symbol.data =
   let (elfname, symname) =
     match elfopt with
     | None ->
@@ -140,7 +140,7 @@ let get_instr arch instr elfopt : BytesSeq.t =
   in
   debug "Got symbol:\n%t\n" (Pp.topi Elf.Symbol.pp_raw sym);
   let len = 4 (* TODO proper Instruction length system *) in
-  BytesSeq.sub sym.data.data off len (*TODO relocations*)
+  Elf.Symbol.sub sym off len
 
 let instr_term = Term.(CmdlinerHelper.func_options comopts get_instr $ arch $ instr $ elf)
 
@@ -148,15 +148,24 @@ let simp_trace_term = Term.(const ( || ) $ simp_trace $ simp)
 
 let simp_state_term = Term.(const ( || ) $ simp_state $ simp)
 
-let get_traces _instr _isla_run _dump_types : traces =
-  Raise.todo()
-  (* Isla.Cache.start @@ Arch.get_isla_config ();
+let get_traces (instr: Elf.Symbol.data) isla_run dump_types : traces =
+  Isla.Cache.start @@ Arch.get_isla_config ();
   (* I call Init.init manually to print the register types *)
   Init.init () |> ignore;
-  let rtraces = Isla.Cache.get_traces (instr, None) in (* TODO relocs *)
+  let reloc = Elf.Relocations.IMap.find_opt 0 instr.relocations in
+  let reloc_typ = Option.map (fun (x: Elf.Relocations.rel) -> x.target) reloc in
+  let segments, rtraces = match Isla.Cache.get_traces (instr.data, reloc_typ) with
+  | Isla.Traces tr -> [], tr
+  | Isla.TracesWithSegments (Segments s, tr) -> s, tr
+  in
   List.iter (fun t -> Isla.Type.type_trc t |> ignore) rtraces;
   if dump_types then base "Register types:\n%t\n" (Pp.topi State.Reg.pp_index ());
-  if isla_run then IslaTraces rtraces else Traces (List.map Trace.of_isla rtraces) *)
+  if isla_run then (
+    if not @@ List.is_empty segments then
+      Raise.fail "Isla run doesn't support symbolic opcodes";
+    IslaTraces rtraces
+  ) else
+    Traces (reloc, List.map (Trace.of_isla segments) rtraces)
 
 let pre_traces_term = Term.(const get_traces $ instr_term $ isla_run $ reg_types)
 
@@ -164,9 +173,9 @@ let simp_traces simp_traces traces =
   if simp_traces then (
     match traces with
     | IslaTraces _ -> traces
-    | Traces trcs ->
+    | Traces (reloc, trcs) ->
         Z3.ensure_started ();
-        Traces (List.map Trace.simplify trcs)
+        Traces (reloc, List.map Trace.simplify trcs)
   )
   else traces
 
@@ -176,7 +185,7 @@ let dump_traces dump_traces traces =
       match traces with
       | IslaTraces trcs ->
           List.iteri (fun i trc -> base "Trace %d:\n%t\n" i (Pp.topi Isla.pp_trc trc)) trcs
-      | Traces trcs ->
+      | Traces (_reloc, trcs) ->
           List.iteri (fun i trc -> base "Trace %d:\n%t\n" i (Pp.topi Trace.pp trc)) trcs
   end;
   traces
@@ -192,7 +201,7 @@ let run_instr dump_init norun simp_state traces =
       match traces with
       | IslaTraces trcs ->
           List.map ((Isla.Run.trc [@ocaml.warning "-3"] (* deprecated *)) init_state) trcs
-      | Traces trcs -> List.map (Trace.Run.trace init_state) trcs
+      | Traces (relocation, trcs) -> List.map (Trace.Run.trace ?relocation init_state) trcs
     in
     let states =
       if simp_state then begin

From 320f7642625e198a1f66377fede350f646e03496 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 20 Jul 2025 17:46:18 +0200
Subject: [PATCH 098/116] Allow parsing absolute addresses

---
 src/elf/symTable.ml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/elf/symTable.ml b/src/elf/symTable.ml
index 095cee81..93207a20 100644
--- a/src/elf/symTable.ml
+++ b/src/elf/symTable.ml
@@ -152,8 +152,11 @@ let sym_offset_of_string t s : sym_offset =
 let of_position_string t s : sym_offset =
   let s = String.trim s in
   if s = "" then raise Not_found;
-  if s.[0] = '0' then raise Not_found (* no absolute addresses *) (* TODO handle absolute addresses *)
-  else sym_offset_of_string t s
+
+  if s.[0] = '0' then
+    of_addr_with_offset t (Address.absolute (int_of_string s))
+  else
+    sym_offset_of_string t s
 
 let of_linksem_generic get_typ of_linksem linksem_map =
   let add_linksem_sym_to_map (map : t) lsym =

From 34cbb38578619faf7ef4055a07c999b4bcd9d0d9 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sun, 20 Jul 2025 18:11:25 +0200
Subject: [PATCH 099/116] Comment on bit sizes used by relocation expressions

---
 src/state/base.ml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index fb4381fa..9a1443d1 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -245,9 +245,11 @@ module Relocation = struct
   }
 
   let rec exp_of_relocation_exp: Elf.Relocations.exp -> exp = 
+    (* Note: the expressions are on 64bit integers, which should be enough to avoid overflow
+       (address space is usally smaller than 64 bits). Could consider using 128bit just to be safe (TODO). *)
     let f = exp_of_relocation_exp in function
-    | Section s -> Exp.of_var (Var.Section s) (* TODO size? *)
-    | Const x -> Typed.bits (BitVec.of_int x ~size:64) (* TODO size? *)
+    | Section s -> Exp.of_var (Var.Section s)
+    | Const x -> Typed.bits (BitVec.of_int x ~size:64)
     | BinOp (a, Add, b) -> Typed.(f a + f b)
     | BinOp (a, Sub, b) -> Typed.(f a - f b)
     | BinOp (a, And, b) -> Typed.manyop (AstGen.Ott.Bvmanyarith AstGen.Ott.Bvand) [f a; f b]

From 9a414ea538f11ade17fcc03cecfd645e4d56802c Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 21 Jul 2025 12:33:45 +0200
Subject: [PATCH 100/116] Use 0 as initial last_pc value (less ambiguous)

---
 src/state/base.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 9a1443d1..1f92f410 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -495,7 +495,7 @@ let make ?elf () =
       mem = Mem.empty ();
       elf;
       fenv = Fragment.Env.make ();
-      last_pc = Elf.Address.{ section = Some ".text"; offset = 0 }; (* TODO is this right? *)
+      last_pc = Elf.Address.absolute 0
     }
   in
   next_id := id + 1;

From e8166a6e79c7321774ed57de8d1f69b8c6bb332c Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 21 Jul 2025 12:43:07 +0200
Subject: [PATCH 101/116] Resolve TODO

---
 src/trace/typer.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index d8b8c664..d596b670 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -222,7 +222,7 @@ let rec expr ~ctxt (exp : Base.exp) : Ctype.t option =
     | Var (Register reg, _) -> State.get_reg ctxt.state reg |> State.Tval.ctyp
     | Var (Read (r, _), _) -> HashVector.get ctxt.mem_reads r |> State.Tval.ctyp
     | Var (NonDet _, _) -> None
-    | Var (Segment _, _) -> None (* TODO? *)
+    | Var (Segment _, _) -> None (* Bitsize is usually not whole bytes, so cannot be typed properly in this system *)
     | Bits (bv, _) ->
         let size = BitVec.size bv in
         if size mod 8 = 0 || size = Arch.address_size then

From 97e188a7b7a4cf5616045e7ed8ff1044ae396862 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Mon, 21 Jul 2025 13:04:49 +0200
Subject: [PATCH 102/116] Reloc byte seq

---
 src/arch/aarch64/sig.ml  | 2 +-
 src/arch/riscv64/sig.ml  | 2 +-
 src/elf/relocBytesSeq.ml | 4 ++++
 src/elf/symbol.ml        | 9 +++------
 src/elf/symbol.mli       | 5 +----
 src/run/runner.ml        | 2 +-
 6 files changed, 11 insertions(+), 13 deletions(-)
 create mode 100644 src/elf/relocBytesSeq.ml

diff --git a/src/arch/aarch64/sig.ml b/src/arch/aarch64/sig.ml
index c46bb8b8..0dadfb20 100644
--- a/src/arch/aarch64/sig.ml
+++ b/src/arch/aarch64/sig.ml
@@ -368,7 +368,7 @@ let split_into_instrs (data: Elf.Symbol.data) =
       let (_, rel, rest) = IMap.split pos data.relocations in
       if Option.is_some @@ IMap.find_first_opt (fun i -> i < pos + 4) rest then
         Raise.fail "Misaligned relocation";      
-      Elf.Symbol.{
+      Elf.RelocBytesSeq.{
         data = bytes;
         relocations = rel |> Option.map (IMap.singleton 0) |> Option.value ~default:IMap.empty;
       }
diff --git a/src/arch/riscv64/sig.ml b/src/arch/riscv64/sig.ml
index 4f661598..7b28e6cd 100644
--- a/src/arch/riscv64/sig.ml
+++ b/src/arch/riscv64/sig.ml
@@ -324,7 +324,7 @@ let split_into_instrs (data: Elf.Symbol.data) =
       let (_, rel, rest) = IMap.split pos data.relocations in
       if Option.is_some @@ IMap.find_first_opt (fun i -> i < pos + 4) rest then
         Raise.fail "Misaligned relocation";      
-      Elf.Symbol.{
+      Elf.RelocBytesSeq.{
         data = bytes;
         relocations = rel |> Option.map (IMap.singleton 0) |> Option.value ~default:IMap.empty;
       }
diff --git a/src/elf/relocBytesSeq.ml b/src/elf/relocBytesSeq.ml
new file mode 100644
index 00000000..2b7497ae
--- /dev/null
+++ b/src/elf/relocBytesSeq.ml
@@ -0,0 +1,4 @@
+type t = {
+  data: BytesSeq.t;
+  relocations: Relocations.t
+}
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 0e66a393..99c30c9d 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -52,10 +52,7 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
-type data = {
-  data: BytesSeq.t;
-  relocations: Relocations.t
-}
+type data = RelocBytesSeq.t
 
 type t = {
   name : string;
@@ -108,7 +105,7 @@ let of_linksem_relocatable (name, (typ, size, addr, (data, rels), _), writable)
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
   let addr = Address.of_linksem_relocatable addr in
-  let data = { data; relocations = Relocations.of_linksem rels } in
+  let data : data = { data; relocations = Relocations.of_linksem rels } in
   (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
 
@@ -132,7 +129,7 @@ let is_interesting = function OBJECT | FUNC -> true | _ -> false
 
 let is_interesting_linksem get_typ lsym = lsym |> get_typ |> typ_of_linksem |> is_interesting
 
-let sub sym off len = {
+let sub sym off len : data = {
   data = BytesSeq.sub sym.data.data off len;
   relocations = Relocations.sub sym.data.relocations off len;
 }
diff --git a/src/elf/symbol.mli b/src/elf/symbol.mli
index 7ed2b952..5557a9eb 100644
--- a/src/elf/symbol.mli
+++ b/src/elf/symbol.mli
@@ -55,10 +55,7 @@ type typ = NOTYPE | OBJECT | FUNC | SECTION | FILE | UNKNOWN
 
 type linksem_typ = Z.t
 
-type data = {
-  data: BytesSeq.t;
-  relocations: Relocations.t
-}
+type data = RelocBytesSeq.t
 
 (** The ELF symbol. This type guarantee the data exists contrary to linksem symbols
     (it may be all zeros though) *)
diff --git a/src/run/runner.ml b/src/run/runner.ml
index 8f311eec..e8edcb8e 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -98,7 +98,7 @@ let load_sym runner (sym : Elf.Symbol.t) =
   let opcode_list = Arch.split_into_instrs sym.data in
   let addr = ref sym.addr in
   List.iter
-    (fun Elf.Symbol.{ data = code; relocations } ->
+    (fun Elf.RelocBytesSeq.{ data = code; relocations } ->
       let (addr, instr_len) =
         let result = !addr and len = BytesSeq.length code in
         addr := Elf.Address.(!addr + len);

From b0efce6a70af42f033c9d05b09b485d7b3607914 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 14:02:12 +0200
Subject: [PATCH 103/116] Use RelocByteSeq

---
 src/elf/relocBytesSeq.ml | 22 ++++++++++++++++++++++
 src/elf/relocations.ml   |  4 +++-
 src/elf/symbol.ml        | 13 +++++--------
 src/run/instr.ml         |  6 +++---
 src/run/runner.ml        | 10 +++++-----
 5 files changed, 38 insertions(+), 17 deletions(-)

diff --git a/src/elf/relocBytesSeq.ml b/src/elf/relocBytesSeq.ml
index 2b7497ae..94993e40 100644
--- a/src/elf/relocBytesSeq.ml
+++ b/src/elf/relocBytesSeq.ml
@@ -2,3 +2,25 @@ type t = {
   data: BytesSeq.t;
   relocations: Relocations.t
 }
+
+type linksem_t = BytesSeq.t * LinksemRelocatable.sym_data
+
+let sub seq off len = {
+  data = BytesSeq.sub seq.data off len;
+  relocations = Relocations.sub seq.relocations off len;
+}
+
+let of_linksem (data, rel) = { data; relocations=Relocations.of_linksem rel }
+
+let pp seq = Pp.(pair (BytesSeq.ppby ~by:4) Relocations.pp (seq.data, seq.relocations))
+
+let of_bytes_seq data = { data; relocations=Relocations.empty }
+
+(* Special case where only a single relocation is allowed *)
+(* used by the executor *)
+type opcode = BytesSeq.t * Relocations.rel
+
+let as_opcode seq =
+  (seq.data, Relocations.IMap.find_opt 0 seq.relocations)
+  
+let length seq = BytesSeq.length seq.data
diff --git a/src/elf/relocations.ml b/src/elf/relocations.ml
index 04117864..6e07fa6b 100644
--- a/src/elf/relocations.ml
+++ b/src/elf/relocations.ml
@@ -89,4 +89,6 @@ let pp rels =
   if IMap.is_empty rels then
     Pp.empty
   else
-    Pp.(mapping "relocations" @@ List.map (fun (i, r) -> (hex i, pp_rel r)) (IMap.to_list rels))
\ No newline at end of file
+    Pp.(mapping "relocations" @@ List.map (fun (i, r) -> (hex i, pp_rel r)) (IMap.to_list rels))
+
+let empty : t = IMap.empty
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 99c30c9d..27a8b370 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -101,11 +101,11 @@ let _ =
 (* module SMap = Map.Make (String)
 let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000 *)
 
-let of_linksem_relocatable (name, (typ, size, addr, (data, rels), _), writable) =
+let of_linksem_relocatable (name, (typ, size, addr, data, _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in
   let addr = Address.of_linksem_relocatable addr in
-  let data : data = { data; relocations = Relocations.of_linksem rels } in
+  let data = RelocBytesSeq.of_linksem data in
   (* let addr = SMap.find section locs + Z.to_int offset in *)
   { name; other_names = []; typ; size; addr; data; writable }
 
@@ -123,16 +123,13 @@ let of_linksem_executable segs (name, (typ, size, addr, data, _)) =
       (* TODO use some wrapper for byte sequences with relocations *)
       Segment.get_addr (fun (bs, _) -> BytesSeq.getbs ~len:size bs) segment addr)
   in
-  { name; other_names = []; typ; size; addr=Address.absolute addr; data={data; relocations=Relocations.IMap.empty}; writable }
+  { name; other_names = []; typ; size; addr=Address.absolute addr; data=RelocBytesSeq.of_bytes_seq data; writable }
 
 let is_interesting = function OBJECT | FUNC -> true | _ -> false
 
 let is_interesting_linksem get_typ lsym = lsym |> get_typ |> typ_of_linksem |> is_interesting
 
-let sub sym off len : data = {
-  data = BytesSeq.sub sym.data.data off len;
-  relocations = Relocations.sub sym.data.relocations off len;
-}
+let sub sym off len = RelocBytesSeq.sub sym.data off len
 
 let compare s1 s2 = compare s1.addr s2.addr
 
@@ -159,5 +156,5 @@ let pp_raw sym =
            (* ("addr", ptr sym.addr); *)
            ("size", ptr sym.size);
            ("writable", bool sym.writable);
-           ("data", pair (BytesSeq.ppby ~by:4) Relocations.pp (sym.data.data, sym.data.relocations));
+           ("data", RelocBytesSeq.pp sym.data);
          ])
diff --git a/src/run/instr.ml b/src/run/instr.ml
index 07c15d78..9b0f8623 100644
--- a/src/run/instr.ml
+++ b/src/run/instr.ml
@@ -148,13 +148,13 @@ let simp_trace_term = Term.(const ( || ) $ simp_trace $ simp)
 
 let simp_state_term = Term.(const ( || ) $ simp_state $ simp)
 
-let get_traces (instr: Elf.Symbol.data) isla_run dump_types : traces =
+let get_traces (instr: Elf.RelocBytesSeq.t) isla_run dump_types : traces =
   Isla.Cache.start @@ Arch.get_isla_config ();
   (* I call Init.init manually to print the register types *)
   Init.init () |> ignore;
-  let reloc = Elf.Relocations.IMap.find_opt 0 instr.relocations in
+  let (data, reloc) = Elf.RelocBytesSeq.as_opcode instr in
   let reloc_typ = Option.map (fun (x: Elf.Relocations.rel) -> x.target) reloc in
-  let segments, rtraces = match Isla.Cache.get_traces (instr.data, reloc_typ) with
+  let segments, rtraces = match Isla.Cache.get_traces (data, reloc_typ) with
   | Isla.Traces tr -> [], tr
   | Isla.TracesWithSegments (Segments s, tr) -> s, tr
   in
diff --git a/src/run/runner.ml b/src/run/runner.ml
index e8edcb8e..3c389d83 100644
--- a/src/run/runner.ml
+++ b/src/run/runner.ml
@@ -98,16 +98,16 @@ let load_sym runner (sym : Elf.Symbol.t) =
   let opcode_list = Arch.split_into_instrs sym.data in
   let addr = ref sym.addr in
   List.iter
-    (fun Elf.RelocBytesSeq.{ data = code; relocations } ->
+    (fun code ->
       let (addr, instr_len) =
-        let result = !addr and len = BytesSeq.length code in
+        let result = !addr and len = Elf.RelocBytesSeq.length code in
         addr := Elf.Address.(!addr + len);
         (result, len)
       in
-      debug "Relocation at address %t: %t" (Pp.top Elf.Address.pp addr) (Pp.top Elf.Relocations.pp relocations);
+      debug "Relocation at address %t: %t" (Pp.top Elf.Address.pp addr) (Pp.top Elf.Relocations.pp code.relocations);
       try
-        let reloc = Elf.Relocations.IMap.find_opt 0 relocations in
-        let instr = Trace.Cache.get_instr (code, reloc) in
+        let opc = Elf.RelocBytesSeq.as_opcode code in
+        let instr = Trace.Cache.get_instr opc in
         if instr.traces = [] then begin
           debug "Instruction at %t in %s is loaded as special" (Pp.top Elf.Address.pp addr) sym.name;
           Hashtbl.add runner.instrs addr (Special instr_len)

From da3095e8019cf2e626b2b66d769873f90ef603a7 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 14:21:31 +0200
Subject: [PATCH 104/116] Use RelocBytesSeq in Elf.Segment

---
 src/elf/file.ml          | 4 ++--
 src/elf/relocBytesSeq.ml | 6 ++++++
 src/elf/segment.ml       | 4 ++--
 src/elf/symbol.ml        | 2 +-
 src/state/base.ml        | 6 ++----
 5 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index bafd91d0..8e05a3ae 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -163,7 +163,7 @@ let of_relocatable_file (filename : string) elf64_file =
         sname,
         Segment.
         {
-          data = (data, relocations);
+          data = {data; relocations};
           addr = 0; (* Meaningless for relocatable files *)
           size = BytesSeq.length data;
           read = true;
@@ -228,7 +228,7 @@ let of_executable_file (filename : string) =
     in
     Segment.
       {
-        data=(data, Relocations.IMap.empty);
+        data=RelocBytesSeq.of_bytes_seq data;
         addr = Sym.to_int addr;
         size = BytesSeq.length data;
         read = true;
diff --git a/src/elf/relocBytesSeq.ml b/src/elf/relocBytesSeq.ml
index 94993e40..28e693eb 100644
--- a/src/elf/relocBytesSeq.ml
+++ b/src/elf/relocBytesSeq.ml
@@ -24,3 +24,9 @@ let as_opcode seq =
   (seq.data, Relocations.IMap.find_opt 0 seq.relocations)
   
 let length seq = BytesSeq.length seq.data
+
+let expect_bs_no_relocations {data; relocations} =
+  if Relocations.IMap.is_empty relocations then
+    data
+  else
+    failwith "Byte sequence has relocations"
diff --git a/src/elf/segment.ml b/src/elf/segment.ml
index 51b82009..fc138e99 100644
--- a/src/elf/segment.ml
+++ b/src/elf/segment.ml
@@ -51,7 +51,7 @@
 
 (** The type of a segment *)
 type t = {
-  data : BytesSeq.t * Relocations.t;
+  data : RelocBytesSeq.t;
   addr : int;  (** The actual start address of the BytesSeq *)
   size : int;  (** redundant with {!Utils.BytesSeq.length} data *)
   read : bool;
@@ -66,7 +66,7 @@ let of_linksem (lseg : Elf_interpreted_segment.elf64_interpreted_segment) : t =
   BytesSeq.blit lseg.elf64_segment_body 0 bytes 0 (Z.to_int lseg.elf64_segment_size);
   let (read, write, execute) = lseg.elf64_segment_flags in
   {
-    data = BytesSeq.of_bytes bytes, Relocations.IMap.empty;
+    data = RelocBytesSeq.of_bytes_seq (BytesSeq.of_bytes bytes);
     addr = Z.to_int lseg.elf64_segment_base;
     size;
     read;
diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 27a8b370..593a9744 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -121,7 +121,7 @@ let of_linksem_executable segs (name, (typ, size, addr, data, _)) =
     data
     |> Option.value_fun ~default:(fun () ->
       (* TODO use some wrapper for byte sequences with relocations *)
-      Segment.get_addr (fun (bs, _) -> BytesSeq.getbs ~len:size bs) segment addr)
+      Segment.get_addr Fun.(RelocBytesSeq.expect_bs_no_relocations %> BytesSeq.getbs ~len:size) segment addr)
   in
   { name; other_names = []; typ; size; addr=Address.absolute addr; data=RelocBytesSeq.of_bytes_seq data; writable }
 
diff --git a/src/state/base.ml b/src/state/base.ml
index 1f92f410..b3ed1eb5 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -623,10 +623,8 @@ let read_from_rodata (s : t) ~(addr : Exp.t) ~(size : Mem.Size.t) : Exp.t option
         let rodata_section = Option.value sym_addr.section ~default:".rodata" in
         let* rodata = Elf.File.SMap.find_opt rodata_section elf.rodata in
         if rodata.addr <= int_addr && int_addr + size <= rodata.addr + rodata.size then
-          let data, relocations = rodata.data in
-          let data = BytesSeq.sub data (int_addr - rodata.addr) size in
-          let relocations = Elf.Relocations.sub relocations (int_addr - rodata.addr) size in
-          let value, asserts = Relocation.exp_of_data {data; relocations} in
+          let data = Elf.RelocBytesSeq.sub rodata.data (int_addr - rodata.addr) size in
+          let value, asserts = Relocation.exp_of_data data in
           
           if not @@ List.is_empty asserts then
             warn "Relocaiton assserts in .rodata ignored: %t" Pp.(top (list Exp.pp) asserts);

From 935547dba71a94ce898c6f6b7000d02427045c2f Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 17:31:11 +0200
Subject: [PATCH 105/116] Enable run-bb

---
 src/isla/base.ml   |  5 +++++
 src/run/BB.ml      |  4 ++--
 src/run/bb_lib.ml  | 23 +++++++++++++----------
 src/run/instr.ml   |  5 +----
 src/trace/cache.ml |  5 +----
 5 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/src/isla/base.ml b/src/isla/base.ml
index 94f4788b..5c2f190a 100644
--- a/src/isla/base.ml
+++ b/src/isla/base.ml
@@ -211,6 +211,11 @@ let parse_segments_channel ?filename (c : in_channel) : instruction_segments =
     | exn -> assert_failure (Printf.sprintf "Thrown: %s" (Printexc.to_string exn))
 *)
 
+
+let trcs_to_list = function
+| Traces trcs -> [], trcs
+| TracesWithSegments (Segments s, trcs) -> s, trcs
+
 (*****************************************************************************)
 (*****************************************************************************)
 (*****************************************************************************)
diff --git a/src/run/BB.ml b/src/run/BB.ml
index cdddee56..223148e7 100644
--- a/src/run/BB.ml
+++ b/src/run/BB.ml
@@ -93,7 +93,7 @@ let len =
   in
   Arg.(value & opt (some int) None & info ["l"; "len"] ~doc)
 
-let get_code elfname symname len : BytesSeq.t =
+let get_code elfname symname len : Elf.RelocBytesSeq.t =
   let elf = Elf.File.of_file elfname in
   Arch.load_elf_arch elf;
   let (sym, off) =
@@ -101,7 +101,7 @@ let get_code elfname symname len : BytesSeq.t =
     with Not_found -> fail "The symbol %s cannot found in %s" symname elfname
   in
   let len = match len with Some i -> i | None -> sym.size - off in
-  (Elf.Symbol.sub sym off len).data (*TODO relocations*)
+  Elf.Symbol.sub sym off len
 
 let code_term = Term.(CmdlinerHelper.func_options comopts get_code $ elf $ sym $ len)
 
diff --git a/src/run/bb_lib.ml b/src/run/bb_lib.ml
index 6790fe1a..58a711d0 100644
--- a/src/run/bb_lib.ml
+++ b/src/run/bb_lib.ml
@@ -64,27 +64,30 @@ type t = { main : trc array }
     Also does the typing of traces for register discovery.
     TODO Support variable length instructions
 *)
-let from_binary (_code : BytesSeq.t) : t =
-  Raise.todo()
-  (* let num = BytesSeq.length code / 4 in
+let from_binary (code : Elf.RelocBytesSeq.t) : t =
   (* TODO fix fixed size instructions *)
-  if BytesSeq.length code != num * 4 then
+  (* TODO maybe this should be checked in Arch.split_into_instrs *)
+  if Elf.RelocBytesSeq.length code mod 4 <> 0 then
     failwith "BB.from_binary: The specified range cuts an instruction";
-  let process (code : BytesSeq.t) : trc =
-    let get_normal : Isla.rtrc list -> trc = function
+  let process (code : Elf.RelocBytesSeq.t) : trc =
+    let get_normal rtrcs =
+      let segs, rtrcs = Isla.trcs_to_list rtrcs in
+      match rtrcs with
       | [] -> failwith "BB.from_binary: no normal path"
       | [trc] ->
           Isla.Type.type_trc trc |> ignore;
-          Trace.of_isla trc
+          Trace.of_isla segs trc
       | _ ->
           failwith
             "BB.from_binary: Multiple path instruction.\n\
              If this is not a branching instruction, try `run-block --linear'."
     in
-    (code, None) |> Isla.Cache.get_traces |> get_normal (*TODO relocs *)
+    let (raw, reloc) = Elf.RelocBytesSeq.as_opcode code in
+    let reloc_typ = Option.map (fun (r : Elf.Relocations.rel) -> r.target) reloc in
+    (raw, reloc_typ) |> Isla.Cache.get_traces |> get_normal
   in
-  let main = code |> BytesSeq.to_listbs ~len:4 |> List.map process |> Array.of_list in
-  { main } *)
+  let main = code |> Arch.split_into_instrs |> List.map process |> Array.of_list in
+  { main }
 
 (* Sequence of the second test:
 mpool.c:116.6  (mpool_fini) 40012240:  37000049  tbnz
diff --git a/src/run/instr.ml b/src/run/instr.ml
index 9b0f8623..16b1e745 100644
--- a/src/run/instr.ml
+++ b/src/run/instr.ml
@@ -154,10 +154,7 @@ let get_traces (instr: Elf.RelocBytesSeq.t) isla_run dump_types : traces =
   Init.init () |> ignore;
   let (data, reloc) = Elf.RelocBytesSeq.as_opcode instr in
   let reloc_typ = Option.map (fun (x: Elf.Relocations.rel) -> x.target) reloc in
-  let segments, rtraces = match Isla.Cache.get_traces (data, reloc_typ) with
-  | Isla.Traces tr -> [], tr
-  | Isla.TracesWithSegments (Segments s, tr) -> s, tr
-  in
+  let segments, rtraces = (data, reloc_typ) |> Isla.Cache.get_traces |> Isla.trcs_to_list in
   List.iter (fun t -> Isla.Type.type_trc t |> ignore) rtraces;
   if dump_types then base "Register types:\n%t\n" (Pp.topi State.Reg.pp_index ());
   if isla_run then (
diff --git a/src/trace/cache.ml b/src/trace/cache.ml
index 7cb5625d..53ad01ef 100644
--- a/src/trace/cache.ml
+++ b/src/trace/cache.ml
@@ -160,10 +160,7 @@ let get_traces (opcode : Isla.Server.opcode) : Base.t list =
   match TC.get_opt cache (Some opcode) with
   | Some trcs -> trcs
   | None ->
-      let segments, isla_traces = match Isla.Cache.get_traces opcode with
-      | Traces t -> [], t
-      | TracesWithSegments (Segments s, t) -> s, t
-      in 
+      let segments, isla_traces = opcode |> Isla.Cache.get_traces |> Isla.trcs_to_list in
       let traces = List.map (tee (Isla.Type.type_trc %> ignore) %> Base.of_isla segments) isla_traces in
       let straces = List.map Base.simplify traces in
       TC.add cache (Some opcode) straces;

From ed23d3d312de35f1ae8e5484e1102597ecc5c1fb Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 17:36:42 +0200
Subject: [PATCH 106/116] Remove leftover debugging stuff

---
 src/elf/symbol.ml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index 593a9744..a65df633 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -97,10 +97,6 @@ let _ =
         Some (Printf.sprintf "Symbol %s at 0x%x could not be loaded" name addr)
     | _ -> None)
 
-(* for debugging TODO remove *)
-(* module SMap = Map.Make (String)
-let locs = SMap.empty |> SMap.add ".text" 0 |> SMap.add ".data" 1000000 |> SMap.add ".eh_frame" 2000000 *)
-
 let of_linksem_relocatable (name, (typ, size, addr, data, _), writable) =
   let typ = typ_of_linksem typ in
   let size = Z.to_int size in

From 92ef1a611d06a7780d61476d10ae248c0b52ba02 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 17:41:15 +0200
Subject: [PATCH 107/116] cleanup todo

---
 src/elf/symbol.ml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/elf/symbol.ml b/src/elf/symbol.ml
index a65df633..ad25dbc0 100644
--- a/src/elf/symbol.ml
+++ b/src/elf/symbol.ml
@@ -116,7 +116,6 @@ let of_linksem_executable segs (name, (typ, size, addr, data, _)) =
   let data =
     data
     |> Option.value_fun ~default:(fun () ->
-      (* TODO use some wrapper for byte sequences with relocations *)
       Segment.get_addr Fun.(RelocBytesSeq.expect_bs_no_relocations %> BytesSeq.getbs ~len:size) segment addr)
   in
   { name; other_names = []; typ; size; addr=Address.absolute addr; data=RelocBytesSeq.of_bytes_seq data; writable }

From db289a0782c51589b34bba22cff2208c23864795 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 17:59:52 +0200
Subject: [PATCH 108/116] Rename sections -> relocatable_sections and clarify
 its usage

It contains a list of sections whose addresses need to be represented symbolically
---
 src/elf/file.ml   | 9 +++++----
 src/state/base.ml | 7 ++++---
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/elf/file.ml b/src/elf/file.ml
index 8e05a3ae..346cba00 100644
--- a/src/elf/file.ml
+++ b/src/elf/file.ml
@@ -93,7 +93,9 @@ type t = {
   linksem : Elf_file.elf_file;
       (** The original linksem structure for the file; only used in  [dw.ml] *)
   rodata : Segment.t SMap.t;  (** The read-only data sections *)
-  sections : section list;
+  relocatable_sections : section list;
+      (** Info about sections' size, alignment, ... constraints. Only used for symbolic execution
+      of relocatable files. *)
 }
 
 (** Error on Elf parsing *)
@@ -174,7 +176,7 @@ let of_relocatable_file (filename : string) elf64_file =
     ) elf64_file.elf64_file_interpreted_sections
   in
   info "ELF file %s has been loaded" filename;
-  { filename; symbols; entry; machine; linksem = elf_file; rodata; sections }
+  { filename; symbols; entry; machine; linksem = elf_file; rodata; relocatable_sections = sections }
 
 let of_executable_file (filename : string) =
   info "Loading ELF file %s" filename;
@@ -237,8 +239,7 @@ let of_executable_file (filename : string) =
       }
   in
   info "ELF file %s has been loaded" filename;
-  (* TODO should we include the section info here as well? *)
-  { filename; symbols; entry; machine; linksem = elf_file; rodata=SMap.singleton ".rodata" rodata; sections = [] }
+  { filename; symbols; entry; machine; linksem = elf_file; rodata=SMap.singleton ".rodata" rodata; relocatable_sections = [] }
 
 
 (** Parse an ELF file to create an {!Elf.File.t} using Linksem.
diff --git a/src/state/base.ml b/src/state/base.ml
index b3ed1eb5..8b608249 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -780,8 +780,9 @@ let init_sections ~sp ~addr_size state =
   let _ = Option.(
     let+ elf = state.elf in
     state.mem.allow_main <- false;
-    push_section_constraints ~sp ~addr_size state elf.sections;
-    List.iter (fun (x:Elf.File.section) -> Mem.create_section_frag ~addr_size state.mem x.name |> ignore) elf.sections;
+    push_section_constraints ~sp ~addr_size state elf.relocatable_sections;
+    List.iter (fun (x:Elf.File.section)
+      -> Mem.create_section_frag ~addr_size state.mem x.name |> ignore) elf.relocatable_sections;
     Elf.SymTable.iter elf.symbols @@ fun sym ->
       let len = List.find (fun x -> sym.size mod x = 0) [16;8;4;2;1] in
       if sym.typ = Elf.Symbol.OBJECT then
@@ -803,7 +804,7 @@ let init_sections_symbolic ~sp ~addr_size state =
   let state = copy_if_locked state in
   let _ = Option.(
     let+ elf = state.elf in
-    push_section_constraints ~sp ~addr_size state elf.sections;
+    push_section_constraints ~sp ~addr_size state elf.relocatable_sections;
     Elf.SymTable.iter elf.symbols @@ fun sym ->
       if sym.typ = Elf.Symbol.OBJECT then
         Option.iter (fun s -> Hashtbl.replace state.mem.sections s Main) sym.addr.section

From a84ce4cfebe780fcb68be4e1cbb1a08acd5e8706 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 18:23:07 +0200
Subject: [PATCH 109/116] Reintroduce global fragment for all ELF sections

---
 src/arch/aarch64/sig.ml | 2 +-
 src/arch/riscv64/sig.ml | 2 +-
 src/ctype/ctype.ml      | 8 ++++----
 src/relsim/relsim.ml    | 5 ++++-
 src/state/base.ml       | 2 +-
 src/trace/typer.ml      | 2 +-
 6 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/arch/aarch64/sig.ml b/src/arch/aarch64/sig.ml
index 0dadfb20..89aaedb8 100644
--- a/src/arch/aarch64/sig.ml
+++ b/src/arch/aarch64/sig.ml
@@ -331,7 +331,7 @@ let get_abi api =
     State.set_reg_type state sp
       (Ctype.of_frag ~provenance:stack_provenance @@ DynFragment stack_frag_id);
     State.set_reg state r30
-      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global ".text")) RetAddr); (* TODO doesn't have to be .text *)
+      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global None)) RetAddr);
     let sp_exp = State.Exp.of_reg state.id sp in
     (* Assert that Sp is 16 bytes aligned *)
     State.push_assert state Exp.Typed.(extract ~last:3 ~first:0 sp_exp = bits_int ~size:4 0);
diff --git a/src/arch/riscv64/sig.ml b/src/arch/riscv64/sig.ml
index 7b28e6cd..5dc8d854 100644
--- a/src/arch/riscv64/sig.ml
+++ b/src/arch/riscv64/sig.ml
@@ -289,7 +289,7 @@ let get_abi api =
     State.set_reg_type state sp
       (Ctype.of_frag ~provenance:stack_provenance @@ DynFragment stack_frag_id);
     State.set_reg state ra
-      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global ".text")) RetAddr);
+      (State.Tval.of_var ~ctyp:(Ctype.of_frag_somewhere (Ctype.Global None)) RetAddr);
     let sp_exp = State.Exp.of_reg state.id sp in
     (* Assert that Sp is 16 bytes aligned *)
     State.push_assert state Exp.Typed.(extract ~last:3 ~first:0 sp_exp = bits_int ~size:4 0);
diff --git a/src/ctype/ctype.ml b/src/ctype/ctype.ml
index cb97ab46..e79cde62 100644
--- a/src/ctype/ctype.ml
+++ b/src/ctype/ctype.ml
@@ -137,10 +137,10 @@ and fragment =
   | Single of t  (** Single object: Only when accessing of a global variable *)
   | DynArray of t  (** Generic C pointer, may point to multiple element of that type *)
   | DynFragment of int  (** Writable fragment for memory whose type is changing dynamically *)
-  (* TODO broken - maybe shouldn't have the section string *)
-  | Global of string
+  | Global of string option
       (** The Global fragment that contains all the fixed ELF section
-               .text, .data, .rodata, ... *)
+               .text, .data, .rodata, ...
+      If a section is given, it is the fragment consisting only of that section *)
 
 (** The type of an offset in a fragment *)
 and offset = Const of int  (** Constant offset *) | Somewhere
@@ -673,7 +673,7 @@ and pp_fragment frag =
   | DynArray t -> pp t ^^ !^"[]"
   | Unknown -> !^"unknown"
   | DynFragment i -> dprintf "frag %d" i
-  | Global s -> !^"global " ^^ !^s
+  | Global s -> !^"global " ^^ optional string s
 
 and pp_offset = function
   | Const off when off = 0 -> empty
diff --git a/src/relsim/relsim.ml b/src/relsim/relsim.ml
index 3146a1b4..c6e0db0d 100644
--- a/src/relsim/relsim.ml
+++ b/src/relsim/relsim.ml
@@ -70,9 +70,12 @@ let rec sem_type_of_type (typ: Ctype.t) : sem_type =
   | Ptr { fragment=Ctype.DynArray typ'; _ } -> Ptr (sem_type_of_type typ')
   | _ -> Raise.todo()
 
+let unknown_section_counter = Counter.make 0
+
 let value_rel_for_type: Ctype.unqualified -> value_relation = function
 | Ctype.Machine _ | Ctype.Cint _ | Ctype.Cbool | Ctype.Enum _ -> Eq
-| Ptr { fragment=Ctype.Global s; _ } -> EqSection s
+| Ptr { fragment=Ctype.Global Some s; _ } -> EqSection s
+| Ptr { fragment=Ctype.Global None; _ } -> EqSection ("Unknown_"^string_of_int (Counter.get unknown_section_counter))
 | Ptr { fragment=Ctype.DynFragment i; _ } -> EqSection ("Dyn_"^string_of_int i)
 | Ptr { fragment=Ctype.DynArray typ'; _ } -> Indirect (sem_type_of_type typ')
 | _ -> Raise.todo()
diff --git a/src/state/base.ml b/src/state/base.ml
index 8b608249..26e8d0f8 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -712,7 +712,7 @@ let update_reg_exp (s : t) (reg : Reg.t) (f : exp -> exp) =
 
 let set_pc ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
   let exp = Exp.of_address ~size:64 pcval in
-  let ctyp = Ctype.of_frag (Ctype.Global ".text") ~offset:pcval.offset ~constexpr:true in
+  let ctyp = Ctype.of_frag (Ctype.Global pcval.section) ~offset:pcval.offset ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
   
 
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index d596b670..ed6a98fc 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -300,7 +300,7 @@ let fragment_at ~(dwarf : Dw.t) ~fenv ~size (frag : Ctype.fragment) at : Ctype.t
       let* (typ, off) = Fragment.at_off_opt frag at in
       Ctype.type_at ~env ~size typ off
   | Global s -> (
-      match Elf.SymTable.of_addr_with_offset_opt dwarf.elf.symbols Elf.Address.{ section = Some s; offset = at } with
+      match Elf.SymTable.of_addr_with_offset_opt dwarf.elf.symbols Elf.Address.{ section = s; offset = at } with
       | Some (sym, offset) -> (
           match Hashtbl.find_opt dwarf.vars sym.name with
           | Some v -> Ctype.type_at ~env ~size v.ctype offset

From 652931b940a1d040940ab3ac06f2792972d39339 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 19:12:16 +0200
Subject: [PATCH 110/116] Fix form of PC value

The executor expects exactly the form section+offset, but previously it was set to section[63:0]+offset
---
 src/state/base.ml  | 19 ++++++++++---------
 src/state/base.mli |  4 ++--
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 26e8d0f8..0ffaa050 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -192,16 +192,17 @@ module Exp = struct
     let offset = BitVec.to_int conc in
     Elf.Address.{ section = section; offset }
   
-  let of_section ~(size : int) (section : string) =
-    Typed.extract ~last:(size-1) ~first:0
-        (of_var @@ Var.Section section)
-
-
-  let of_address ~(size : int) (addr : Elf.Address.t) =
+  let of_section ?(size : int option) (section : string) =
+    let s = of_var @@ Var.Section section in
+    match size with
+    | None -> s
+    | Some size -> Typed.extract ~last:(size-1) ~first:0 s
+    
+  let of_address ?(size : int option) (addr : Elf.Address.t) =
     Typed.(
-      let offset = bits_int ~size addr.offset in
+      let offset = bits_int ~size:(Option.value ~default:64 size) addr.offset in
       match addr.section with
-      | Some section -> of_section ~size section + offset
+      | Some section -> of_section ?size section + offset
       | None -> offset
     )
 end
@@ -711,7 +712,7 @@ let update_reg_exp (s : t) (reg : Reg.t) (f : exp -> exp) =
   Reg.Map.get s.regs reg |> Tval.map_exp f |> Reg.Map.set s.regs reg
 
 let set_pc ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
-  let exp = Exp.of_address ~size:64 pcval in
+  let exp = Exp.of_address pcval in
   let ctyp = Ctype.of_frag (Ctype.Global pcval.section) ~offset:pcval.offset ~constexpr:true in
   set_reg s pc @@ Tval.make ~ctyp exp
   
diff --git a/src/state/base.mli b/src/state/base.mli
index 696fe923..f0702dda 100644
--- a/src/state/base.mli
+++ b/src/state/base.mli
@@ -164,9 +164,9 @@ module Exp : sig
 
   val expect_address : t -> Elf.Address.t
 
-  val of_section : size:int -> string -> t
+  val of_section : ?size:int -> string -> t
 
-  val of_address : size:int -> Elf.Address.t -> t
+  val of_address : ?size:int -> Elf.Address.t -> t
 end
 
 type exp = Exp.t

From 85b24f783bbc073994cfb81d9b4bf047e73684b6 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Thu, 31 Jul 2025 19:44:41 +0200
Subject: [PATCH 111/116] Fix: stop emiting error about values being typed
 constexpr

---
 src/state/base.ml  |  3 ++-
 src/trace/typer.ml | 20 ++++++++++++--------
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/state/base.ml b/src/state/base.ml
index 0ffaa050..391a9639 100644
--- a/src/state/base.ml
+++ b/src/state/base.ml
@@ -713,7 +713,8 @@ let update_reg_exp (s : t) (reg : Reg.t) (f : exp -> exp) =
 
 let set_pc ~(pc : Reg.t) (s : t) (pcval : Elf.Address.t) =
   let exp = Exp.of_address pcval in
-  let ctyp = Ctype.of_frag (Ctype.Global pcval.section) ~offset:pcval.offset ~constexpr:true in
+  let constexpr = Option.is_none pcval.section in
+  let ctyp = Ctype.of_frag (Ctype.Global pcval.section) ~offset:pcval.offset ~constexpr in
   set_reg s pc @@ Tval.make ~ctyp exp
   
 
diff --git a/src/trace/typer.ml b/src/trace/typer.ml
index ed6a98fc..161cc76b 100644
--- a/src/trace/typer.ml
+++ b/src/trace/typer.ml
@@ -202,14 +202,18 @@ let manyop ~ctxt (m : Ast.manyop) (tvals : tval list) : Ctype.t option =
           match offset with
           | Somewhere -> Some ctyp
           | Const _ -> (
-              try
-                let new_int =
-                  constexpr_to_int ~ctxt (Typed.concat (List.map (fun t -> t.exp) tvals))
-                in
-                debug "concat hack: %x = %t" new_int
-                  (Pp.top Base.pp_exp (Typed.concat (List.map (fun t -> t.exp) tvals)));
-                Some (Ctype.ptr_set ctyp new_int)
-              with ConcreteEval.Symbolic -> Ctype.ptr_forget ctyp |> Option.some
+              if (List.for_all (fun t -> Option.exists (fun (typ:Ctype.t) -> typ.constexpr) t.ctyp) tvals) then
+                (* if all are constexpr *)
+                try
+                  let new_int =
+                    constexpr_to_int ~ctxt (Typed.concat (List.map (fun t -> t.exp) tvals))
+                  in
+                  debug "concat hack: %x = %t" new_int
+                    (Pp.top Base.pp_exp (Typed.concat (List.map (fun t -> t.exp) tvals)));
+                  Some (Ctype.ptr_set ctyp new_int)
+                with ConcreteEval.Symbolic -> Ctype.ptr_forget ctyp |> Option.some
+              else
+                Ctype.ptr_forget ctyp |> Option.some
             )
         )
       | _ -> None

From d9fb48ae980b2c062b99f6f2089eccd338066f2a Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Sat, 2 Aug 2025 19:00:03 +0200
Subject: [PATCH 112/116] Allow running isla test with relocations

---
 src/isla/test.ml | 56 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 20 deletions(-)

diff --git a/src/isla/test.ml b/src/isla/test.ml
index b7a06ad7..6d5839d3 100644
--- a/src/isla/test.ml
+++ b/src/isla/test.ml
@@ -153,11 +153,11 @@ let input_f2m file sym : imode Term.ret =
 let imode_term = Term.(ret (const input_f2m $ file $ sym))
 
 (** Input takes the imode and the main argument and returns the filename and input string *)
-let input imode (arg : string) : (string * string) Term.ret =
+let input imode (arg : string) : (string * string * Relocation.t option) Term.ret =
   match imode with
-  | CMD -> `Ok ("CLI input", arg)
+  | CMD -> `Ok ("CLI input", arg, None)
   | FILE -> (
-      try `Ok (arg, read_string arg) with e -> `Error (false, Printexc.to_string e)
+      try `Ok (arg, read_string arg, None) with e -> `Error (false, Printexc.to_string e)
     )
   | ELF s ->
       let filename = s ^ " in " ^ arg in
@@ -166,7 +166,12 @@ let input imode (arg : string) : (string * string) Term.ret =
         try Elf.SymTable.of_position_string elf.symbols s
         with Not_found -> fail "The position %s could not be found in %s" s arg
       in
-      `Ok (filename, BytesSeq.to_string (BytesSeq.sub sym.data.data off 4)) (* TODO relocations *)
+      let data, reloc = Elf.RelocBytesSeq.as_opcode @@ Elf.Symbol.sub sym off 4 in
+      let reloc_typ = Option.map (fun (r : Elf.Relocations.rel) ->
+        base "Instruction has a relocation, executing symbolically";
+        r.target
+      ) reloc in
+      `Ok (filename, BytesSeq.to_string data, reloc_typ)
 
 let input_term = Term.(ret (const input $ imode_term $ arg))
 
@@ -183,28 +188,30 @@ let isla_f2m direct hex bin sym : isla_mode Term.ret =
 let isla_mode_term =
   Term.(ret (CmdlinerHelper.func_option Logs.term isla_f2m $ direct $ hex $ bin $ sym))
 
-let isla_mode_to_request imode input =
+let isla_mode_to_request imode input reloc_typ =
   match imode with
-  | ASM -> Server.TEXT_ASM input
-  | HEX -> Server.ASM (BytesSeq.of_hex input, None) (* TODO? *)
-  | BIN -> Server.ASM (BytesSeq.of_string input, None)
+  | ASM ->
+      Option.iter (fun r -> warn "Relocation is ignored %t" (Pp.top Elf.Relocations.pp_target r)) reloc_typ;
+      Server.TEXT_ASM input
+  | HEX -> Server.ASM (BytesSeq.of_hex input, reloc_typ)
+  | BIN -> Server.ASM (BytesSeq.of_string input, reloc_typ)
   | _ -> assert false
 
 (** Run isla and return a text trace with a filename
     (if mode is RAW than just return the trace and filename without isla)
 
     If isla return multiple traces, just silently pick the first non-exceptional one *)
-let isla_run isla_mode arch (filename, input) : string * string * Server.config =
+let isla_run isla_mode arch (filename, input, reloc_typ) : string * (string option * string) * Server.config =
   match isla_mode with
-  | RAW -> (filename, input, Config.File.get_isla_config arch)
+  | RAW -> (filename, (None, input), Config.File.get_isla_config arch)
   | _ ->
       Server.(
         Random.self_init ();
         let config = ConfigFile.get_isla_config arch in
         start config;
-        let msg : string =
-          match request (isla_mode_to_request isla_mode input) with
-          | Traces (_, l) -> List.assoc true l (* TODO segments *)
+        let msg : string option * string =
+          match request (isla_mode_to_request isla_mode input reloc_typ) with
+          | Traces (segs, l) -> segs, List.assoc true l
           | _ -> failwith "isla did not send back traces"
         in
         stop ();
@@ -224,27 +231,36 @@ let processing_f2m noparse typer run simp =
 let pmode_term = Term.(const processing_f2m $ noparse $ typer $ run $ simp)
 
 (** Does the actual processing of the trace *)
-let processing preprocessing pmode (filename, input, (config : Server.config)) : unit =
+let processing preprocessing pmode (filename, (segments, input), (config : Server.config)) : unit =
   let parse input =
+    let segments =
+      Option.map Fun.(Base.parse_segments_string ~filename %> function Segments s -> s) segments
+      |> Option.value ~default:[]
+    in
+    let num_segments = List.length segments in
     let t = Base.parse_trc_string ~filename input in
     let t = Manip.remove_ignored config.ignored_regs t in
+    if num_segments <> 0 then
+      base "Instrction segments:\n%t\n" (Pp.top Base.pp_instruction_segments (Segments segments));
     if preprocessing then begin
-      let pre = Preprocess.simplify_trc t in
+      let pre = Preprocess.simplify_trc ~num_segments t in
       base "Preprocessed trace:\n%t\n" (Pp.topi Base.pp_trc pre);
-      pre
+      pre, segments
     end
     else begin
       base "Trace:\n%t\n" (Pp.topi Base.pp_trc t);
-      t
+      t, segments
     end
   in
-  let typer t =
+  let typer (t, s) =
     let c = Type.type_trc t in
     base "Isla vars typing context:\n%t\n" (Pp.topi Type.pp_tcontext c);
     base "Register types:\n%t\n" (Pp.topi State.Reg.pp_index ());
-    t
+    (t, s)
   in
-  let run trace =
+  let run (trace, s) =
+    if not (List.is_empty s) then
+      fail "Cannot run a trace with instruction segments";
     let init_state = State.make () in
     State.lock init_state;
     base "Initial state:\n%t\n" (Pp.topi State.pp init_state);

From 16d01d162eef354ccf6af01bc7252397e7edec7c Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 12 Aug 2025 16:56:43 +0200
Subject: [PATCH 113/116] Remove "horrible hack"

---
 src/analyse/ControlFlow.ml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 5089c761..7f63e745 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -452,19 +452,19 @@ AArch64:
  *)
 
 (* matej version *)
-(*
+
 let relocation_regexp_string = "[ \t][0-9a-fA-F]+:[ \t]\\([0-9A-Z_]+\\)\t\\(.*\\)"
 
 let objdump_line_regexp =
   Str.regexp (" *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\)[ \t]*\\([^:]*\\)\\(" ^ relocation_regexp_string ^ "\\)?$")
-*)
-(* ps version *)
 
+(* ps version *)
+(* 
 let relocation_regexp_string = "%[ \t]+[0-9a-fA-F]+:[ \t]+\\([0-9A-Z_]+\\)[ \t]+\\(.*\\)"
 
 let objdump_line_regexp =
   Str.regexp (" *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\)[ \t]*\\([^%]*\\)\\(" ^ relocation_regexp_string ^ "\\)?$")
-
+*)
 let section_start_line_regexp =
   Str.regexp "Disassembly of section \\(.*\\):$"
 

From a0aada10a44993e58ff888a2b5483bad2e35b509 Mon Sep 17 00:00:00 2001
From: Matej Urban <maturvo@gmail.com>
Date: Tue, 12 Aug 2025 17:16:17 +0200
Subject: [PATCH 114/116] Warn about weird lines in objdump

---
 src/analyse/ControlFlow.ml | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/analyse/ControlFlow.ml b/src/analyse/ControlFlow.ml
index 7f63e745..2130814c 100644
--- a/src/analyse/ControlFlow.ml
+++ b/src/analyse/ControlFlow.ml
@@ -458,6 +458,8 @@ let relocation_regexp_string = "[ \t][0-9a-fA-F]+:[ \t]\\([0-9A-Z_]+\\)\t\\(.*\\
 let objdump_line_regexp =
   Str.regexp (" *\\([0-9a-fA-F]+\\):[ \t]\\([0-9a-fA-F ]+\\)\t\\([^ \r\t\n]+\\)[ \t]*\\([^:]*\\)\\(" ^ relocation_regexp_string ^ "\\)?$")
 
+let objdump_command = "aarch64-linux-gnu-objdump -d  --reloc -w"
+
 (* ps version *)
 (* 
 let relocation_regexp_string = "%[ \t]+[0-9a-fA-F]+:[ \t]+\\([0-9A-Z_]+\\)[ \t]+\\(.*\\)"
@@ -525,6 +527,10 @@ let parse_objdump_line (s : string) : raw_objdump_instruction option =
     end
   else None
 
+let looks_like_objdump_line (s : string) : bool =
+  let regex = Str.regexp "[ \t]*[0-9a-fA-F]+:.*$" in
+  Str.string_match regex s 0
+
 (* let parse_objdump_relocation (s : string) : (string * string) option =
   let parse_hex_int s' =
     try Scanf.sscanf s' "%x" (fun i -> i)
@@ -561,7 +567,10 @@ let rec parse_objdump_lines arch lines (next_index : int) (last_address : int64
     let section = Option.fold ~none:section ~some:Option.some @@ parse_section_start lines.(next_index) in
     match parse_objdump_line lines.(next_index) with
     (* skip over unparseable lines *)
-    | None -> parse_objdump_lines arch lines (next_index + 1) last_address section
+    | None ->
+        if looks_like_objdump_line lines.(next_index) then
+          warn "Skipping unparseable objdump line %d: %s\nIf parsing aarch64 with relocations, generate objdump using: %s" next_index lines.(next_index) objdump_command;
+        parse_objdump_lines arch lines (next_index + 1) last_address section
     | Some ((addr, _opcode_bytes, _mnemonic, _operands, _relocation) as i) -> (
         let mki = with_symbolic_address (Option.get section) in
         match last_address with

From f7a569178490ed2c06409391485eb60e07b7ae6c Mon Sep 17 00:00:00 2001
From: Peter Sewell <Peter.Sewell@cl.cam.ac.uk>
Date: Fri, 15 Aug 2025 11:38:44 +0100
Subject: [PATCH 115/116] add nm to isla_aarch64.toml, following
 isla/configs/armv8p5.toml

---
 src/config/isla_aarch64.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/config/isla_aarch64.toml b/src/config/isla_aarch64.toml
index f762a682..d8d7d61c 100644
--- a/src/config/isla_aarch64.toml
+++ b/src/config/isla_aarch64.toml
@@ -14,12 +14,14 @@ os = "macos"
 arch = "aarch64"
 assembler = "as --target=aarch64-unknown-linux-gnu"
 objdump = "/opt/homebrew/opt/llvm/bin/llvm-objdump"
+nm = "/opt/homebrew/opt/llvm/bin/llvm-nm"
 linker = "/opt/homebrew/opt/llvm/bin/ld.lld"
 
 [[toolchain]]
 name = "default"
 assembler = "aarch64-linux-gnu-as -march=armv8.1-a"
 objdump = "aarch64-linux-gnu-objdump"
+nm = "aarch64-linux-gnu-nm"
 linker = "aarch64-linux-gnu-ld"
 
 [mmu]

From af9d06a016b6bba1c5411dfc615e55e9f19e8790 Mon Sep 17 00:00:00 2001
From: Peter Sewell <Peter.Sewell@cl.cam.ac.uk>
Date: Fri, 15 Aug 2025 11:59:58 +0100
Subject: [PATCH 116/116] wib

---
 doc/html/index.html                           |  2 +-
 doc/html/read-dwarf/Analyse/Base/index.html   |  2 +-
 .../read-dwarf/Analyse/Collected/index.html   |  6 +-
 .../Analyse/DwarfLineInfo/index.html          | 30 ++++++++-
 doc/html/read-dwarf/Analyse/Elf/index.html    |  2 +-
 .../read-dwarf/Analyse/ElfTypes/index.html    | 10 ++-
 .../read-dwarf/Analyse/Globals/index.html     |  2 +-
 doc/html/read-dwarf/Analyse/Pp/index.html     | 50 ++++++++++++++-
 doc/html/read-dwarf/Analyse/Types/index.html  |  2 +-
 doc/html/read-dwarf/Analyse/Utils/index.html  |  2 +-
 doc/html/read-dwarf/Analyse/index.html        |  2 +-
 doc/html/read-dwarf/Arch/index.html           |  2 +-
 doc/html/read-dwarf/Architecture.html         |  2 +-
 doc/html/read-dwarf/Ast/Base/Size/index.html  |  2 +-
 doc/html/read-dwarf/Ast/Base/index.html       | 57 ++++++++++++++++-
 doc/html/read-dwarf/Ast/Manip/index.html      | 35 +++++++++-
 doc/html/read-dwarf/Ast/index.html            | 57 ++++++++++++++++-
 .../read-dwarf/AstGen/Def/Size/index.html     |  2 +-
 doc/html/read-dwarf/AstGen/Def/index.html     |  9 ++-
 doc/html/read-dwarf/AstGen/Lexer/index.html   |  2 +-
 doc/html/read-dwarf/AstGen/Ott/index.html     |  5 +-
 doc/html/read-dwarf/AstGen/Parser/index.html  | 14 +++-
 .../read-dwarf/AstGen/Parser_pp/index.html    | 32 +++++++++-
 doc/html/read-dwarf/AstGen/index.html         |  2 +-
 doc/html/read-dwarf/BinaryAnalysis.html       |  2 +-
 doc/html/read-dwarf/CLI.html                  |  2 +-
 doc/html/read-dwarf/Config/Arch/index.html    |  2 +-
 .../read-dwarf/Config/CommonOpt/index.html    |  7 +-
 .../Config/File/ArchConf/Isla/index.html      |  2 +-
 .../Config/File/ArchConf/index.html           |  2 +-
 doc/html/read-dwarf/Config/File/Z3/index.html |  2 +-
 doc/html/read-dwarf/Config/File/index.html    |  2 +-
 doc/html/read-dwarf/Config/index.html         |  2 +-
 .../Config/module-type-S/index.html           |  2 +-
 doc/html/read-dwarf/Configuration.html        |  2 +-
 doc/html/read-dwarf/Ctype/FieldMap/index.html | 15 +++--
 doc/html/read-dwarf/Ctype/index.html          | 64 ++++++++++++++++++-
 doc/html/read-dwarf/Dw/Func/index.html        |  2 +-
 doc/html/read-dwarf/Dw/Loc/index.html         |  2 +-
 doc/html/read-dwarf/Dw/Var/index.html         |  4 +-
 doc/html/read-dwarf/Dw/index.html             |  2 +-
 doc/html/read-dwarf/Elf/File/index.html       |  2 +-
 doc/html/read-dwarf/Elf/Segment/index.html    | 10 ++-
 doc/html/read-dwarf/Elf/SymTable/index.html   |  2 +-
 doc/html/read-dwarf/Elf/Symbol/index.html     |  2 +-
 doc/html/read-dwarf/Elf/index.html            |  2 +-
 .../read-dwarf/Exp/ConcreteEval/index.html    |  2 +-
 .../Exp/Make/argument-1-Var/index.html        |  2 +-
 doc/html/read-dwarf/Exp/Make/index.html       |  2 +-
 doc/html/read-dwarf/Exp/PpExp/index.html      | 16 ++++-
 doc/html/read-dwarf/Exp/Sums/index.html       | 12 +++-
 doc/html/read-dwarf/Exp/Typed/index.html      |  7 +-
 doc/html/read-dwarf/Exp/Value/index.html      |  2 +-
 doc/html/read-dwarf/Exp/index.html            |  2 +-
 .../read-dwarf/Exp/module-type-S/index.html   |  2 +-
 .../read-dwarf/Exp/module-type-Var/index.html |  2 +-
 doc/html/read-dwarf/InstructionPipeline.html  |  2 +-
 doc/html/read-dwarf/Isla/Base/index.html      | 25 +++++++-
 .../read-dwarf/Isla/Cache/Epoch/index.html    |  2 +-
 doc/html/read-dwarf/Isla/Cache/IC/index.html  |  2 +-
 .../read-dwarf/Isla/Cache/Opcode/index.html   |  8 ++-
 .../Isla/Cache/TraceList/index.html           |  2 +-
 doc/html/read-dwarf/Isla/Cache/index.html     |  2 +-
 doc/html/read-dwarf/Isla/Conv/index.html      | 11 +++-
 doc/html/read-dwarf/Isla/Manip/index.html     | 22 ++++++-
 .../read-dwarf/Isla/Preprocess/index.html     |  2 +-
 doc/html/read-dwarf/Isla/Run/index.html       |  6 +-
 .../read-dwarf/Isla/Server/Cmd/index.html     |  2 +-
 doc/html/read-dwarf/Isla/Server/index.html    |  2 +-
 doc/html/read-dwarf/Isla/Test/index.html      |  6 +-
 doc/html/read-dwarf/Isla/Type/index.html      | 16 ++++-
 doc/html/read-dwarf/Isla/index.html           | 25 +++++++-
 .../Other_cmds/CopySources/index.html         |  2 +-
 .../Other_cmds/CopySourcesCmd/index.html      |  2 +-
 .../Other_cmds/DumpDwarf/index.html           |  2 +-
 .../read-dwarf/Other_cmds/DumpSym/index.html  |  2 +-
 .../Other_cmds/ReadDwarf/Default/index.html   |  2 +-
 .../Other_cmds/ReadDwarf/index.html           |  2 +-
 doc/html/read-dwarf/Other_cmds/index.html     |  2 +-
 doc/html/read-dwarf/Printing.html             |  2 +-
 doc/html/read-dwarf/Qtest_isla/index.html     |  2 +-
 doc/html/read-dwarf/Qtest_run/index.html      |  2 +-
 .../read-dwarf/Qtest_sig_aarch64/index.html   |  2 +-
 doc/html/read-dwarf/Qtest_utils/index.html    |  2 +-
 doc/html/read-dwarf/Run/BB/index.html         |  2 +-
 doc/html/read-dwarf/Run/Bb_lib/index.html     |  2 +-
 doc/html/read-dwarf/Run/Block/index.html      |  9 ++-
 doc/html/read-dwarf/Run/Block_lib/index.html  | 18 +++++-
 doc/html/read-dwarf/Run/Func/index.html       | 14 +++-
 doc/html/read-dwarf/Run/FuncRD/index.html     |  8 ++-
 doc/html/read-dwarf/Run/Init/index.html       |  2 +-
 doc/html/read-dwarf/Run/Instr/index.html      |  2 +-
 doc/html/read-dwarf/Run/ReadDwarf/index.html  |  2 +-
 doc/html/read-dwarf/Run/Runner/index.html     |  8 ++-
 doc/html/read-dwarf/Run/index.html            |  2 +-
 doc/html/read-dwarf/Sig/index.html            |  2 +-
 .../read-dwarf/Simrel/Base/MemRel/index.html  |  5 +-
 .../read-dwarf/Simrel/Base/RegRel/index.html  |  6 +-
 .../read-dwarf/Simrel/Base/Test2/index.html   |  2 +-
 .../read-dwarf/Simrel/Base/Test3/index.html   |  2 +-
 doc/html/read-dwarf/Simrel/Base/index.html    |  9 ++-
 doc/html/read-dwarf/Simrel/index.html         |  2 +-
 doc/html/read-dwarf/State/Base/Exp/index.html |  2 +-
 doc/html/read-dwarf/State/Base/Id/index.html  |  2 +-
 .../State/Base/Mem/Fragment/Block/index.html  |  2 +-
 .../State/Base/Mem/Fragment/Event/index.html  |  2 +-
 .../State/Base/Mem/Fragment/index.html        |  2 +-
 doc/html/read-dwarf/State/Base/Mem/index.html |  2 +-
 .../read-dwarf/State/Base/Tval/index.html     |  2 +-
 doc/html/read-dwarf/State/Base/Var/index.html |  2 +-
 doc/html/read-dwarf/State/Base/index.html     | 14 +++-
 .../read-dwarf/State/Fragment/Env/index.html  |  2 +-
 doc/html/read-dwarf/State/Fragment/index.html | 15 +++--
 doc/html/read-dwarf/State/Reg/Map/index.html  |  2 +-
 doc/html/read-dwarf/State/Reg/Path/index.html |  2 +-
 doc/html/read-dwarf/State/Reg/index.html      |  2 +-
 .../State/Simplify/ContextFull/index.html     |  2 +-
 .../State/Simplify/Z3St/Htbl/index.html       |  2 +-
 .../read-dwarf/State/Simplify/Z3St/index.html |  2 +-
 doc/html/read-dwarf/State/Simplify/index.html |  2 +-
 .../Make/argument-1-Var/index.html            |  2 +-
 .../State/SymbolicBytes/Make/index.html       |  2 +-
 .../read-dwarf/State/SymbolicBytes/index.html |  2 +-
 .../SymbolicBytes/module-type-S/index.html    |  2 +-
 doc/html/read-dwarf/State/Tree/index.html     |  2 +-
 doc/html/read-dwarf/State/index.html          | 14 +++-
 doc/html/read-dwarf/SymbolicExecution.html    |  2 +-
 doc/html/read-dwarf/SymbolicExpressions.html  |  2 +-
 .../read-dwarf/Tests/BytesSeqT/index.html     |  2 +-
 .../read-dwarf/Tests/Common/Gen/index.html    | 43 ++++++++++++-
 doc/html/read-dwarf/Tests/Common/index.html   |  2 +-
 .../read-dwarf/Tests/ConcreteEvalT/index.html | 14 +++-
 .../read-dwarf/Tests/ExpGen/ExpT/index.html   |  2 +-
 .../read-dwarf/Tests/ExpGen/Gen/index.html    |  5 +-
 .../read-dwarf/Tests/ExpGen/Var/index.html    |  2 +-
 .../Tests/ExpGen/Z3/Htbl/index.html           |  2 +-
 .../read-dwarf/Tests/ExpGen/Z3/index.html     |  2 +-
 doc/html/read-dwarf/Tests/ExpGen/index.html   |  9 ++-
 .../read-dwarf/Tests/SimplifyCheck/index.html | 14 +++-
 doc/html/read-dwarf/Tests/index.html          |  2 +-
 doc/html/read-dwarf/Trace/Base/Exp/index.html |  2 +-
 .../Trace/Base/SimpContext/index.html         |  2 +-
 doc/html/read-dwarf/Trace/Base/Var/index.html |  2 +-
 .../read-dwarf/Trace/Base/VarTbl/index.html   |  2 +-
 .../Trace/Base/Z3Tr/Htbl/index.html           |  2 +-
 .../read-dwarf/Trace/Base/Z3Tr/index.html     |  2 +-
 doc/html/read-dwarf/Trace/Base/index.html     | 14 +++-
 doc/html/read-dwarf/Trace/Cache/TC/index.html |  2 +-
 .../read-dwarf/Trace/Cache/Traces/index.html  |  2 +-
 doc/html/read-dwarf/Trace/Cache/index.html    |  2 +-
 doc/html/read-dwarf/Trace/Context/index.html  |  6 +-
 doc/html/read-dwarf/Trace/Instr/index.html    |  5 +-
 doc/html/read-dwarf/Trace/Run/index.html      | 18 +++++-
 doc/html/read-dwarf/Trace/index.html          | 13 +++-
 doc/html/read-dwarf/TypeInference.html        |  2 +-
 doc/html/read-dwarf/Utilities.html            |  2 +-
 doc/html/read-dwarf/Utils/Array/index.html    |  6 +-
 doc/html/read-dwarf/Utils/BitVec/index.html   |  8 ++-
 doc/html/read-dwarf/Utils/Bits/index.html     |  2 +-
 doc/html/read-dwarf/Utils/BytesSeq/index.html |  2 +-
 .../Utils/Cache/Cmd/Test/Cache/index.html     |  2 +-
 .../Utils/Cache/Cmd/Test/Single/index.html    |  2 +-
 .../Utils/Cache/Cmd/Test/Value/index.html     |  2 +-
 .../Utils/Cache/Cmd/Test/index.html           |  2 +-
 .../read-dwarf/Utils/Cache/Cmd/index.html     |  2 +-
 .../Utils/Cache/IntEpoch/index.html           |  2 +-
 .../Cache/Make/argument-1-Key/index.html      |  2 +-
 .../Cache/Make/argument-2-Value/index.html    |  2 +-
 .../Cache/Make/argument-3-Epoch/index.html    |  2 +-
 .../read-dwarf/Utils/Cache/Make/index.html    |  2 +-
 .../Cache/Single/argument-1-Value/index.html  |  2 +-
 .../read-dwarf/Utils/Cache/Single/index.html  |  2 +-
 .../Utils/Cache/UnitEpoch/index.html          |  2 +-
 doc/html/read-dwarf/Utils/Cache/index.html    |  6 +-
 .../Utils/Cache/module-type-Epoch/index.html  |  2 +-
 .../Utils/Cache/module-type-Key/index.html    |  2 +-
 .../Utils/Cache/module-type-S/index.html      |  2 +-
 .../Cache/module-type-SingleS/index.html      |  2 +-
 .../Utils/Cache/module-type-Value/index.html  |  2 +-
 .../read-dwarf/Utils/Cmd/IOServer/index.html  |  2 +-
 .../Utils/Cmd/SocketServer/index.html         |  2 +-
 doc/html/read-dwarf/Utils/Cmd/index.html      |  6 +-
 .../Utils/CmdlinerHelper/index.html           |  8 ++-
 doc/html/read-dwarf/Utils/Counter/index.html  |  4 +-
 doc/html/read-dwarf/Utils/Files/index.html    |  2 +-
 doc/html/read-dwarf/Utils/FullVec/index.html  |  2 +-
 doc/html/read-dwarf/Utils/Fun/index.html      |  2 +-
 .../read-dwarf/Utils/HashVector/index.html    |  2 +-
 doc/html/read-dwarf/Utils/IdMap/index.html    |  7 +-
 doc/html/read-dwarf/Utils/IntBits/index.html  |  2 +-
 doc/html/read-dwarf/Utils/List/index.html     | 16 ++++-
 .../Utils/Logs/Logger/argument-1-S/index.html |  2 +-
 .../read-dwarf/Utils/Logs/Logger/index.html   |  4 +-
 doc/html/read-dwarf/Utils/Logs/index.html     | 12 +++-
 .../Utils/Logs/module-type-String/index.html  |  2 +-
 doc/html/read-dwarf/Utils/Option/index.html   |  2 +-
 doc/html/read-dwarf/Utils/Pair/index.html     | 12 +++-
 .../Utils/Pp/class-type-custom/index.html     |  2 +-
 .../Utils/Pp/class-type-output/index.html     |  2 +-
 doc/html/read-dwarf/Utils/Pp/index.html       | 50 +++++++++++++--
 doc/html/read-dwarf/Utils/Protect/index.html  |  2 +-
 doc/html/read-dwarf/Utils/Raise/index.html    |  2 +-
 .../read-dwarf/Utils/RngMap/IMap/index.html   |  6 +-
 .../RngMap/Make/argument-1-Obj/index.html     |  2 +-
 .../read-dwarf/Utils/RngMap/Make/index.html   | 15 +++--
 .../PairLenObject/argument-1-Obj/index.html   |  2 +-
 .../Utils/RngMap/PairLenObject/index.html     |  2 +-
 doc/html/read-dwarf/Utils/RngMap/index.html   |  2 +-
 .../RngMap/module-type-LenObject/index.html   |  2 +-
 .../RngMap/module-type-Object/index.html      |  2 +-
 .../Utils/RngMap/module-type-S/index.html     | 15 +++--
 doc/html/read-dwarf/Utils/Seq/index.html      |  2 +-
 doc/html/read-dwarf/Utils/String/index.html   |  2 +-
 doc/html/read-dwarf/Utils/Vec/index.html      |  2 +-
 doc/html/read-dwarf/Utils/WeakMap/index.html  |  2 +-
 doc/html/read-dwarf/Utils/WeakPtr/index.html  |  2 +-
 doc/html/read-dwarf/Utils/index.html          |  2 +-
 .../read-dwarf/Z3/CheckContext/index.html     |  2 +-
 .../Z3/ContextCounter/argument-1-S/index.html |  2 +-
 .../read-dwarf/Z3/ContextCounter/index.html   |  2 +-
 .../Z3/Make/argument-1-Var/index.html         |  2 +-
 doc/html/read-dwarf/Z3/Make/index.html        |  2 +-
 doc/html/read-dwarf/Z3/SimpContext/index.html |  2 +-
 doc/html/read-dwarf/Z3/index.html             | 12 +++-
 .../read-dwarf/Z3/module-type-S/index.html    |  2 +-
 .../read-dwarf/Z3/module-type-Var/index.html  |  2 +-
 doc/html/read-dwarf/index.html                |  2 +-
 227 files changed, 1075 insertions(+), 258 deletions(-)

diff --git a/doc/html/index.html b/doc/html/index.html
index 6c320a2b..5a8f3d34 100644
--- a/doc/html/index.html
+++ b/doc/html/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml">
   <head>
     <title>index</title>
-    <link rel="stylesheet" href="./odoc.css"/>
+    <link rel="stylesheet" href="./odoc.support/odoc.css"/>
     <meta charset="utf-8"/>
     <meta name="viewport" content="width=device-width,initial-scale=1.0"/>
   </head>
diff --git a/doc/html/read-dwarf/Analyse/Base/index.html b/doc/html/read-dwarf/Analyse/Base/index.html
index 5e6ed6ad..ff475dd7 100644
--- a/doc/html/read-dwarf/Analyse/Base/index.html
+++ b/doc/html/read-dwarf/Analyse/Base/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Analyse.Base)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Base</nav><h1>Module <code>Analyse.Base</code></h1></header><dl><dt class="spec value" id="val-process_file"><a href="#val-process_file" class="anchor"></a><code><span class="keyword">val</span> process_file : unit <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Analyse.Base)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Base</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Base</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-process_file"><a href="#val-process_file" class="anchor"></a><code><span><span class="keyword">val</span> process_file : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/Collected/index.html b/doc/html/read-dwarf/Analyse/Collected/index.html
index 969e6d4e..b0c2c3cf 100644
--- a/doc/html/read-dwarf/Analyse/Collected/index.html
+++ b/doc/html/read-dwarf/Analyse/Collected/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Collected (read-dwarf.Analyse.Collected)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Collected</nav><h1>Module <code>Analyse.Collected</code></h1><p>collect the various test analysis data</p></header><dl><dt class="spec value" id="val-mk_analysis"><a href="#val-mk_analysis" class="anchor"></a><code><span class="keyword">val</span> mk_analysis : <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>string option</span> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Collected (read-dwarf.Analyse.Collected)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Collected</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Collected</span></code></h1><p>collect the various test analysis data</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-mk_analysis"><a href="#val-mk_analysis" class="anchor"></a><code><span><span class="keyword">val</span> mk_analysis : 
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">Analyse__.CollectedType.analysis</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/DwarfLineInfo/index.html b/doc/html/read-dwarf/Analyse/DwarfLineInfo/index.html
index c07c349e..9fc2be74 100644
--- a/doc/html/read-dwarf/Analyse/DwarfLineInfo/index.html
+++ b/doc/html/read-dwarf/Analyse/DwarfLineInfo/index.html
@@ -1,2 +1,30 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>DwarfLineInfo (read-dwarf.Analyse.DwarfLineInfo)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; DwarfLineInfo</nav><h1>Module <code>Analyse.DwarfLineInfo</code></h1><p>post-process DWARF source line info</p></header><aside><p>post-processed DWARF source line info</p></aside><dl><dt class="spec type" id="type-evaluated_line_info_sequence"><a href="#type-evaluated_line_info_sequence" class="anchor"></a><code><span class="keyword">type</span> evaluated_line_info_sequence</code><code> = </code><code>{</code><table class="record"><tr id="type-evaluated_line_info_sequence.elis_first" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_sequence.elis_first" class="anchor"></a><code>elis_first : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</code></td></tr><tr id="type-evaluated_line_info_sequence.elis_last" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_sequence.elis_last" class="anchor"></a><code>elis_last : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</code></td></tr><tr id="type-evaluated_line_info_sequence.elis_lnh" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_sequence.elis_lnh" class="anchor"></a><code>elis_lnh : Dwarf.line_number_header;</code></td></tr><tr id="type-evaluated_line_info_sequence.elis_lines" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_sequence.elis_lines" class="anchor"></a><code>elis_lines : <span>Dwarf.line_number_registers list</span>;</code></td></tr></table><code>}</code></dt><dt class="spec type" id="type-evaluated_line_info_entry"><a href="#type-evaluated_line_info_entry" class="anchor"></a><code><span class="keyword">type</span> evaluated_line_info_entry</code><code> = </code><code>{</code><table class="record"><tr id="type-evaluated_line_info_entry.elie_first" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_entry.elie_first" class="anchor"></a><code>elie_first : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</code></td></tr><tr id="type-evaluated_line_info_entry.elie_last" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_entry.elie_last" class="anchor"></a><code>elie_last : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</code></td></tr><tr id="type-evaluated_line_info_entry.elie_lnh" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_entry.elie_lnh" class="anchor"></a><code>elie_lnh : Dwarf.line_number_header;</code></td></tr><tr id="type-evaluated_line_info_entry.elie_lnr" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_entry.elie_lnr" class="anchor"></a><code>elie_lnr : Dwarf.line_number_registers;</code></td></tr></table><code>}</code></dt><dt class="spec type" id="type-evaluated_line_info_for_instruction"><a href="#type-evaluated_line_info_for_instruction" class="anchor"></a><code><span class="keyword">type</span> evaluated_line_info_for_instruction</code><code> = </code><code>{</code><table class="record"><tr id="type-evaluated_line_info_for_instruction.elifi_start" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_for_instruction.elifi_start" class="anchor"></a><code>elifi_start : bool;</code></td></tr><tr id="type-evaluated_line_info_for_instruction.elifi_entry" class="anchored"><td class="def field"><a href="#type-evaluated_line_info_for_instruction.elifi_entry" class="anchor"></a><code>elifi_entry : <a href="index.html#type-evaluated_line_info_entry">evaluated_line_info_entry</a>;</code></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-pp_line_number_header_concise"><a href="#val-pp_line_number_header_concise" class="anchor"></a><code><span class="keyword">val</span> pp_line_number_header_concise : Dwarf.line_number_header <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_sequence_concise"><a href="#val-pp_sequence_concise" class="anchor"></a><code><span class="keyword">val</span> pp_sequence_concise : <a href="index.html#type-evaluated_line_info_sequence">evaluated_line_info_sequence</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_elie_concise"><a href="#val-pp_elie_concise" class="anchor"></a><code><span class="keyword">val</span> pp_elie_concise : <a href="index.html#type-evaluated_line_info_entry">evaluated_line_info_entry</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-split_into_sequences"><a href="#val-split_into_sequences" class="anchor"></a><code><span class="keyword">val</span> split_into_sequences : <span>(Dwarf.line_number_header * <span>Dwarf.line_number_registers list</span>)</span> <span>&#45;&gt;</span> <span><a href="index.html#type-evaluated_line_info_sequence">evaluated_line_info_sequence</a> list</span></code></dt><dt class="spec value" id="val-split_into_entries"><a href="#val-split_into_entries" class="anchor"></a><code><span class="keyword">val</span> split_into_entries : <a href="index.html#type-evaluated_line_info_sequence">evaluated_line_info_sequence</a> <span>&#45;&gt;</span> <span><a href="index.html#type-evaluated_line_info_entry">evaluated_line_info_entry</a> list</span></code></dt><dt class="spec value" id="val-mk_line_info"><a href="#val-mk_line_info" class="anchor"></a><code><span class="keyword">val</span> mk_line_info : Dwarf.evaluated_line_info <span>&#45;&gt;</span> <span><a href="../../Analyse__/ControlFlowTypes/index.html#type-instruction">Analyse__.ControlFlowTypes.instruction</a> array</span> <span>&#45;&gt;</span> <span><span><a href="index.html#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> list</span> array</span></code></dt></dl><aside><p>find and pretty-print source lines for addresses</p></aside><dl><dt class="spec value" id="val-source_file_cache"><a href="#val-source_file_cache" class="anchor"></a><code><span class="keyword">val</span> source_file_cache : <span><span><span>(<span>(<span>string option</span> * <span>string option</span> * string)</span> * <span><span>string array</span> option</span>)</span> list</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-actual_directories"><a href="#val-actual_directories" class="anchor"></a><code><span class="keyword">val</span> actual_directories : <span>string option</span> <span>&#45;&gt;</span> <span>(<span>string option</span> * <span>string option</span> * string)</span> <span>&#45;&gt;</span> string * string</code></dt><dt class="spec value" id="val-source_line"><a href="#val-source_line" class="anchor"></a><code><span class="keyword">val</span> source_line : <span>(<span>string option</span> * <span>string option</span> * string)</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>string option</span></code></dt><dt class="spec value" id="val-pp_source_line"><a href="#val-pp_source_line" class="anchor"></a><code><span class="keyword">val</span> pp_source_line : <span>string option</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-mk_subprogram_name"><a href="#val-mk_subprogram_name" class="anchor"></a><code><span class="keyword">val</span> mk_subprogram_name : Dwarf.dwarf_static <span>&#45;&gt;</span> <a href="index.html#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_dwarf_source_file_lines'"><a href="#val-pp_dwarf_source_file_lines'" class="anchor"></a><code><span class="keyword">val</span> pp_dwarf_source_file_lines' : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> Dwarf.dwarf_static <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-dwarf_source_file_line_numbers_by_index"><a href="#val-dwarf_source_file_line_numbers_by_index" class="anchor"></a><code><span class="keyword">val</span> dwarf_source_file_line_numbers_by_index : <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <span><span><a href="index.html#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> list</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span>(string * int)</span> list</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>DwarfLineInfo (read-dwarf.Analyse.DwarfLineInfo)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; DwarfLineInfo</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.DwarfLineInfo</span></code></h1><p>post-process DWARF source line info</p></header><div class="odoc-content"><p>post-processed DWARF source line info</p><div class="odoc-spec"><div class="spec type anchored" id="type-evaluated_line_info_sequence"><a href="#type-evaluated_line_info_sequence" class="anchor"></a><code><span><span class="keyword">type</span> evaluated_line_info_sequence</span><span> = </span><span>{</span></code><ol><li id="type-evaluated_line_info_sequence.elis_first" class="def record field anchored"><a href="#type-evaluated_line_info_sequence.elis_first" class="anchor"></a><code><span>elis_first : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</span></code></li><li id="type-evaluated_line_info_sequence.elis_last" class="def record field anchored"><a href="#type-evaluated_line_info_sequence.elis_last" class="anchor"></a><code><span>elis_last : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</span></code></li><li id="type-evaluated_line_info_sequence.elis_lnh" class="def record field anchored"><a href="#type-evaluated_line_info_sequence.elis_lnh" class="anchor"></a><code><span>elis_lnh : <span class="xref-unresolved">Dwarf</span>.line_number_header;</span></code></li><li id="type-evaluated_line_info_sequence.elis_lines" class="def record field anchored"><a href="#type-evaluated_line_info_sequence.elis_lines" class="anchor"></a><code><span>elis_lines : <span><span class="xref-unresolved">Dwarf</span>.line_number_registers list</span>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-evaluated_line_info_entry"><a href="#type-evaluated_line_info_entry" class="anchor"></a><code><span><span class="keyword">type</span> evaluated_line_info_entry</span><span> = </span><span>{</span></code><ol><li id="type-evaluated_line_info_entry.elie_first" class="def record field anchored"><a href="#type-evaluated_line_info_entry.elie_first" class="anchor"></a><code><span>elie_first : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</span></code></li><li id="type-evaluated_line_info_entry.elie_last" class="def record field anchored"><a href="#type-evaluated_line_info_entry.elie_last" class="anchor"></a><code><span>elie_last : <a href="../Utils/index.html#type-addr">Utils.addr</a>;</span></code></li><li id="type-evaluated_line_info_entry.elie_lnh" class="def record field anchored"><a href="#type-evaluated_line_info_entry.elie_lnh" class="anchor"></a><code><span>elie_lnh : <span class="xref-unresolved">Dwarf</span>.line_number_header;</span></code></li><li id="type-evaluated_line_info_entry.elie_lnr" class="def record field anchored"><a href="#type-evaluated_line_info_entry.elie_lnr" class="anchor"></a><code><span>elie_lnr : <span class="xref-unresolved">Dwarf</span>.line_number_registers;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-evaluated_line_info_for_instruction"><a href="#type-evaluated_line_info_for_instruction" class="anchor"></a><code><span><span class="keyword">type</span> evaluated_line_info_for_instruction</span><span> = </span><span>{</span></code><ol><li id="type-evaluated_line_info_for_instruction.elifi_start" class="def record field anchored"><a href="#type-evaluated_line_info_for_instruction.elifi_start" class="anchor"></a><code><span>elifi_start : bool;</span></code></li><li id="type-evaluated_line_info_for_instruction.elifi_entry" class="def record field anchored"><a href="#type-evaluated_line_info_for_instruction.elifi_entry" class="anchor"></a><code><span>elifi_entry : <a href="#type-evaluated_line_info_entry">evaluated_line_info_entry</a>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_line_number_header_concise"><a href="#val-pp_line_number_header_concise" class="anchor"></a><code><span><span class="keyword">val</span> pp_line_number_header_concise : <span><span class="xref-unresolved">Dwarf</span>.line_number_header <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_sequence_concise"><a href="#val-pp_sequence_concise" class="anchor"></a><code><span><span class="keyword">val</span> pp_sequence_concise : <span><a href="#type-evaluated_line_info_sequence">evaluated_line_info_sequence</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_elie_concise"><a href="#val-pp_elie_concise" class="anchor"></a><code><span><span class="keyword">val</span> pp_elie_concise : <span><a href="#type-evaluated_line_info_entry">evaluated_line_info_entry</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_into_sequences"><a href="#val-split_into_sequences" class="anchor"></a><code><span><span class="keyword">val</span> split_into_sequences : 
+  <span><span>(<span class="xref-unresolved">Dwarf</span>.line_number_header * <span><span class="xref-unresolved">Dwarf</span>.line_number_registers list</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-evaluated_line_info_sequence">evaluated_line_info_sequence</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_into_entries"><a href="#val-split_into_entries" class="anchor"></a><code><span><span class="keyword">val</span> split_into_entries : 
+  <span><a href="#type-evaluated_line_info_sequence">evaluated_line_info_sequence</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-evaluated_line_info_entry">evaluated_line_info_entry</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mk_line_info"><a href="#val-mk_line_info" class="anchor"></a><code><span><span class="keyword">val</span> mk_line_info : 
+  <span><span class="xref-unresolved">Dwarf</span>.evaluated_line_info <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="xref-unresolved">Analyse__.ControlFlowTypes.instruction</span> array</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> list</span> array</span></span></code></div></div><p>find and pretty-print source lines for addresses</p><div class="odoc-spec"><div class="spec value anchored" id="val-source_file_cache"><a href="#val-source_file_cache" class="anchor"></a><code><span><span class="keyword">val</span> source_file_cache : 
+  <span><span><span>(<span>(<span>string option</span> * <span>string option</span> * string)</span> * <span><span>string array</span> option</span>)</span> list</span>
+    <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-actual_directories"><a href="#val-actual_directories" class="anchor"></a><code><span><span class="keyword">val</span> actual_directories : 
+  <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span>string option</span> * <span>string option</span> * string)</span> <span class="arrow">&#45;&gt;</span></span>
+  string * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-source_line"><a href="#val-source_line" class="anchor"></a><code><span><span class="keyword">val</span> source_line : 
+  <span><span>(<span>string option</span> * <span>string option</span> * string)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span>string option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_source_line"><a href="#val-pp_source_line" class="anchor"></a><code><span><span class="keyword">val</span> pp_source_line : <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mk_subprogram_name"><a href="#val-mk_subprogram_name" class="anchor"></a><code><span><span class="keyword">val</span> mk_subprogram_name : 
+  <span><span class="xref-unresolved">Dwarf</span>.dwarf_static <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> <span class="arrow">&#45;&gt;</span></span>
+  string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_dwarf_source_file_lines'"><a href="#val-pp_dwarf_source_file_lines'" class="anchor"></a><code><span><span class="keyword">val</span> pp_dwarf_source_file_lines' : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Dwarf</span>.dwarf_static <span class="arrow">&#45;&gt;</span></span>
+  <span>bool <span class="arrow">&#45;&gt;</span></span>
+  <span>bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> <span class="arrow">&#45;&gt;</span></span>
+  string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dwarf_source_file_line_numbers_by_index"><a href="#val-dwarf_source_file_line_numbers_by_index" class="anchor"></a><code><span><span class="keyword">val</span> dwarf_source_file_line_numbers_by_index : 
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><a href="#type-evaluated_line_info_for_instruction">evaluated_line_info_for_instruction</a> list</span> array</span> <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * int)</span> list</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/Elf/index.html b/doc/html/read-dwarf/Analyse/Elf/index.html
index 44f5e77f..6ce11d14 100644
--- a/doc/html/read-dwarf/Analyse/Elf/index.html
+++ b/doc/html/read-dwarf/Analyse/Elf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Elf (read-dwarf.Analyse.Elf)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Elf</nav><h1>Module <code>Analyse.Elf</code></h1></header><aside><p>pp symbol map</p></aside><dl><dt class="spec value" id="val-pp_symbol_map"><a href="#val-pp_symbol_map" class="anchor"></a><code><span class="keyword">val</span> pp_symbol_map : Elf_file.global_symbol_init_info <span>&#45;&gt;</span> string</code></dt></dl><aside><p>use linksem to parse ELF file and extract DWARF info</p></aside><dl><dt class="spec value" id="val-parse_elf_file"><a href="#val-parse_elf_file" class="anchor"></a><code><span class="keyword">val</span> parse_elf_file : string <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a></code></dt></dl><aside><p>marshal and unmarshal test</p></aside><dl><dt class="spec value" id="val-marshal_to_file"><a href="#val-marshal_to_file" class="anchor"></a><code><span class="keyword">val</span> marshal_to_file : string <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-marshal_from_file"><a href="#val-marshal_from_file" class="anchor"></a><code><span class="keyword">val</span> marshal_from_file : string <span>&#45;&gt;</span> <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> option</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Elf (read-dwarf.Analyse.Elf)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Elf</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Elf</span></code></h1><p>pp symbol map</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-pp_symbol_map"><a href="#val-pp_symbol_map" class="anchor"></a><code><span><span class="keyword">val</span> pp_symbol_map : <span><span class="xref-unresolved">Elf_file</span>.global_symbol_init_info <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><p>use linksem to parse ELF file and extract DWARF info</p><div class="odoc-spec"><div class="spec value anchored" id="val-parse_elf_file"><a href="#val-parse_elf_file" class="anchor"></a><code><span><span class="keyword">val</span> parse_elf_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a></span></code></div></div><p>marshal and unmarshal test</p><div class="odoc-spec"><div class="spec value anchored" id="val-marshal_to_file"><a href="#val-marshal_to_file" class="anchor"></a><code><span><span class="keyword">val</span> marshal_to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-marshal_from_file"><a href="#val-marshal_from_file" class="anchor"></a><code><span><span class="keyword">val</span> marshal_from_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> option</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/ElfTypes/index.html b/doc/html/read-dwarf/Analyse/ElfTypes/index.html
index e6176a29..49ac05e6 100644
--- a/doc/html/read-dwarf/Analyse/ElfTypes/index.html
+++ b/doc/html/read-dwarf/Analyse/ElfTypes/index.html
@@ -1,2 +1,10 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ElfTypes (read-dwarf.Analyse.ElfTypes)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; ElfTypes</nav><h1>Module <code>Analyse.ElfTypes</code></h1><p>type of collected ELF-file data from linksem</p></header><dl><dt class="spec type" id="type-architecture"><a href="#type-architecture" class="anchor"></a><code><span class="keyword">type</span> architecture</code><code> = </code><table class="variant"><tr id="type-architecture.AArch64" class="anchored"><td class="def constructor"><a href="#type-architecture.AArch64" class="anchor"></a><code>| </code><code><span class="constructor">AArch64</span></code></td></tr><tr id="type-architecture.X86" class="anchored"><td class="def constructor"><a href="#type-architecture.X86" class="anchor"></a><code>| </code><code><span class="constructor">X86</span></code></td></tr></table></dt><dd><p>architectures from linksem elf_header.lem</p></dd></dl><aside><p>AMD x86-64 architecture, elf_ma_x86_64 = 62</p></aside><dl><dt class="spec type" id="type-test"><a href="#type-test" class="anchor"></a><code><span class="keyword">type</span> test</code><code> = </code><code>{</code><table class="record"><tr id="type-test.elf_file" class="anchored"><td class="def field"><a href="#type-test.elf_file" class="anchor"></a><code>elf_file : Elf_file.elf_file;</code></td></tr><tr id="type-test.arch" class="anchored"><td class="def field"><a href="#type-test.arch" class="anchor"></a><code>arch : <a href="index.html#type-architecture">architecture</a>;</code></td></tr><tr id="type-test.symbol_map" class="anchored"><td class="def field"><a href="#type-test.symbol_map" class="anchor"></a><code>symbol_map : Elf_file.global_symbol_init_info;</code></td></tr><tr id="type-test.segments" class="anchored"><td class="def field"><a href="#type-test.segments" class="anchor"></a><code>segments : <span>Elf_interpreted_segment.elf64_interpreted_segment list</span>;</code></td></tr><tr id="type-test.e_entry" class="anchored"><td class="def field"><a href="#type-test.e_entry" class="anchor"></a><code>e_entry : <a href="../Utils/index.html#type-natural">Utils.natural</a>;</code></td></tr><tr id="type-test.e_machine" class="anchored"><td class="def field"><a href="#type-test.e_machine" class="anchor"></a><code>e_machine : <a href="../Utils/index.html#type-natural">Utils.natural</a>;</code></td></tr><tr id="type-test.dwarf_static" class="anchored"><td class="def field"><a href="#type-test.dwarf_static" class="anchor"></a><code>dwarf_static : Dwarf.dwarf_static;</code></td></tr><tr id="type-test.dwarf_semi_pp_frame_info" class="anchored"><td class="def field"><a href="#type-test.dwarf_semi_pp_frame_info" class="anchor"></a><code>dwarf_semi_pp_frame_info : <span><span>(<a href="../Utils/index.html#type-natural">Utils.natural</a> * string * <span><span>(string * string)</span> list</span>)</span> list</span>;</code></td></tr></table><code>}</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ElfTypes (read-dwarf.Analyse.ElfTypes)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; ElfTypes</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.ElfTypes</span></code></h1><p>type of collected ELF-file data from linksem</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-architecture"><a href="#type-architecture" class="anchor"></a><code><span><span class="keyword">type</span> architecture</span><span> = </span></code><ol><li id="type-architecture.AArch64" class="def variant constructor anchored"><a href="#type-architecture.AArch64" class="anchor"></a><code><span>| </span><span><span class="constructor">AArch64</span></span></code></li><li id="type-architecture.X86" class="def variant constructor anchored"><a href="#type-architecture.X86" class="anchor"></a><code><span>| </span><span><span class="constructor">X86</span></span></code></li></ol></div><div class="spec-doc"><p>architectures from linksem elf_header.lem</p></div></div><p>AMD x86-64 architecture, elf_ma_x86_64 = 62</p><div class="odoc-spec"><div class="spec type anchored" id="type-test"><a href="#type-test" class="anchor"></a><code><span><span class="keyword">type</span> test</span><span> = </span><span>{</span></code><ol><li id="type-test.elf_file" class="def record field anchored"><a href="#type-test.elf_file" class="anchor"></a><code><span>elf_file : <span class="xref-unresolved">Elf_file</span>.elf_file;</span></code></li><li id="type-test.arch" class="def record field anchored"><a href="#type-test.arch" class="anchor"></a><code><span>arch : <a href="#type-architecture">architecture</a>;</span></code></li><li id="type-test.symbol_map" class="def record field anchored"><a href="#type-test.symbol_map" class="anchor"></a><code><span>symbol_map : <span><span>(string
+              * <span>(<span class="xref-unresolved">Z</span>.t
+                 * <span class="xref-unresolved">Z</span>.t
+                 * <a href="../../Utils/Sym/index.html#type-t">Utils.Sym.t</a>
+                 * <span>(<span class="xref-unresolved">Byte_sequence_wrapper</span>.byte_sequence
+                    * <span class="xref-unresolved">Analyse__.Symbols.rels</span>)</span>
+                 * <span class="xref-unresolved">Z</span>.t)</span>)</span>
+               list</span>;</span></code></li><li id="type-test.e_entry" class="def record field anchored"><a href="#type-test.e_entry" class="anchor"></a><code><span>e_entry : <a href="../Utils/index.html#type-natural">Utils.natural</a>;</span></code></li><li id="type-test.e_machine" class="def record field anchored"><a href="#type-test.e_machine" class="anchor"></a><code><span>e_machine : <a href="../Utils/index.html#type-natural">Utils.natural</a>;</span></code></li><li id="type-test.dwarf_static" class="def record field anchored"><a href="#type-test.dwarf_static" class="anchor"></a><code><span>dwarf_static : <span class="xref-unresolved">Dwarf</span>.dwarf_static;</span></code></li><li id="type-test.dwarf_semi_pp_frame_info" class="def record field anchored"><a href="#type-test.dwarf_semi_pp_frame_info" class="anchor"></a><code><span>dwarf_semi_pp_frame_info : <span><span>(<a href="../Utils/index.html#type-natural">Utils.natural</a> * string * <span><span>(string * string)</span> list</span>)</span>
+                             list</span>;</span></code></li></ol><code><span>}</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/Globals/index.html b/doc/html/read-dwarf/Analyse/Globals/index.html
index e934f8c1..402b9123 100644
--- a/doc/html/read-dwarf/Analyse/Globals/index.html
+++ b/doc/html/read-dwarf/Analyse/Globals/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Globals (read-dwarf.Analyse.Globals)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Globals</nav><h1>Module <code>Analyse.Globals</code></h1></header><dl><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-branch_table_data_file"><a href="#val-branch_table_data_file" class="anchor"></a><code><span class="keyword">val</span> branch_table_data_file : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-objdump_d"><a href="#val-objdump_d" class="anchor"></a><code><span class="keyword">val</span> objdump_d : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-elf2"><a href="#val-elf2" class="anchor"></a><code><span class="keyword">val</span> elf2 : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-branch_table_data_file2"><a href="#val-branch_table_data_file2" class="anchor"></a><code><span class="keyword">val</span> branch_table_data_file2 : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-objdump_d2"><a href="#val-objdump_d2" class="anchor"></a><code><span class="keyword">val</span> objdump_d2 : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-qemu_log"><a href="#val-qemu_log" class="anchor"></a><code><span class="keyword">val</span> qemu_log : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-comp_dir"><a href="#val-comp_dir" class="anchor"></a><code><span class="keyword">val</span> comp_dir : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-cfg_dot_file"><a href="#val-cfg_dot_file" class="anchor"></a><code><span class="keyword">val</span> cfg_dot_file : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-cfg_source_nodes"><a href="#val-cfg_source_nodes" class="anchor"></a><code><span class="keyword">val</span> cfg_source_nodes : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-cfg_source_nodes2"><a href="#val-cfg_source_nodes2" class="anchor"></a><code><span class="keyword">val</span> cfg_source_nodes2 : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-out_file"><a href="#val-out_file" class="anchor"></a><code><span class="keyword">val</span> out_file : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-out_dir"><a href="#val-out_dir" class="anchor"></a><code><span class="keyword">val</span> out_dir : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-clip_binary"><a href="#val-clip_binary" class="anchor"></a><code><span class="keyword">val</span> clip_binary : <span>bool Stdlib.ref</span></code></dt><dt class="spec value" id="val-show_vars"><a href="#val-show_vars" class="anchor"></a><code><span class="keyword">val</span> show_vars : <span>bool Stdlib.ref</span></code></dt><dt class="spec value" id="val-show_cfa"><a href="#val-show_cfa" class="anchor"></a><code><span class="keyword">val</span> show_cfa : <span>bool Stdlib.ref</span></code></dt><dt class="spec value" id="val-show_source"><a href="#val-show_source" class="anchor"></a><code><span class="keyword">val</span> show_source : <span>bool Stdlib.ref</span></code></dt><dt class="spec value" id="val-ppmode"><a href="#val-ppmode" class="anchor"></a><code><span class="keyword">val</span> ppmode : <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> Stdlib.ref</span></code></dt><dt class="spec value" id="val-src_target_dir"><a href="#val-src_target_dir" class="anchor"></a><code><span class="keyword">val</span> src_target_dir : <span><span>string option</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-copy_sources_dry_run"><a href="#val-copy_sources_dry_run" class="anchor"></a><code><span class="keyword">val</span> copy_sources_dry_run : <span>bool Stdlib.ref</span></code></dt><dt class="spec value" id="val-skylight"><a href="#val-skylight" class="anchor"></a><code><span class="keyword">val</span> skylight : <span>bool Stdlib.ref</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Globals (read-dwarf.Analyse.Globals)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Globals</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Globals</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-branch_table_data_file"><a href="#val-branch_table_data_file" class="anchor"></a><code><span><span class="keyword">val</span> branch_table_data_file : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-objdump_d"><a href="#val-objdump_d" class="anchor"></a><code><span><span class="keyword">val</span> objdump_d : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf2"><a href="#val-elf2" class="anchor"></a><code><span><span class="keyword">val</span> elf2 : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-branch_table_data_file2"><a href="#val-branch_table_data_file2" class="anchor"></a><code><span><span class="keyword">val</span> branch_table_data_file2 : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-objdump_d2"><a href="#val-objdump_d2" class="anchor"></a><code><span><span class="keyword">val</span> objdump_d2 : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-qemu_log"><a href="#val-qemu_log" class="anchor"></a><code><span><span class="keyword">val</span> qemu_log : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-comp_dir"><a href="#val-comp_dir" class="anchor"></a><code><span><span class="keyword">val</span> comp_dir : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfg_dot_file"><a href="#val-cfg_dot_file" class="anchor"></a><code><span><span class="keyword">val</span> cfg_dot_file : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfg_source_nodes"><a href="#val-cfg_source_nodes" class="anchor"></a><code><span><span class="keyword">val</span> cfg_source_nodes : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfg_source_nodes2"><a href="#val-cfg_source_nodes2" class="anchor"></a><code><span><span class="keyword">val</span> cfg_source_nodes2 : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-out_file"><a href="#val-out_file" class="anchor"></a><code><span><span class="keyword">val</span> out_file : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-out_dir"><a href="#val-out_dir" class="anchor"></a><code><span><span class="keyword">val</span> out_dir : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clip_binary"><a href="#val-clip_binary" class="anchor"></a><code><span><span class="keyword">val</span> clip_binary : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-show_vars"><a href="#val-show_vars" class="anchor"></a><code><span><span class="keyword">val</span> show_vars : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-show_cfa"><a href="#val-show_cfa" class="anchor"></a><code><span><span class="keyword">val</span> show_cfa : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-show_source"><a href="#val-show_source" class="anchor"></a><code><span><span class="keyword">val</span> show_source : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppmode"><a href="#val-ppmode" class="anchor"></a><code><span><span class="keyword">val</span> ppmode : <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-src_target_dir"><a href="#val-src_target_dir" class="anchor"></a><code><span><span class="keyword">val</span> src_target_dir : <span><span>string option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy_sources_dry_run"><a href="#val-copy_sources_dry_run" class="anchor"></a><code><span><span class="keyword">val</span> copy_sources_dry_run : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-skylight"><a href="#val-skylight" class="anchor"></a><code><span><span class="keyword">val</span> skylight : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-morello"><a href="#val-morello" class="anchor"></a><code><span><span class="keyword">val</span> morello : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-suppress_stuff"><a href="#val-suppress_stuff" class="anchor"></a><code><span><span class="keyword">val</span> suppress_stuff : <span>bool <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/Pp/index.html b/doc/html/read-dwarf/Analyse/Pp/index.html
index 1b63518b..45efa3f1 100644
--- a/doc/html/read-dwarf/Analyse/Pp/index.html
+++ b/doc/html/read-dwarf/Analyse/Pp/index.html
@@ -1,2 +1,50 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Pp (read-dwarf.Analyse.Pp)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Pp</nav><h1>Module <code>Analyse.Pp</code></h1></header><aside><p>render collected analysis data to text or css</p></aside><dl><dt class="spec type" id="type-render_kind"><a href="#type-render_kind" class="anchor"></a><code><span class="keyword">type</span> render_kind</code><code> = </code><table class="variant"><tr id="type-render_kind.Render_symbol_star" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_symbol_star" class="anchor"></a><code>| </code><code><span class="constructor">Render_symbol_star</span></code></td></tr><tr id="type-render_kind.Render_symbol_nostar" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_symbol_nostar" class="anchor"></a><code>| </code><code><span class="constructor">Render_symbol_nostar</span></code></td></tr><tr id="type-render_kind.Render_source" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_source" class="anchor"></a><code>| </code><code><span class="constructor">Render_source</span></code></td></tr><tr id="type-render_kind.Render_frame" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_frame" class="anchor"></a><code>| </code><code><span class="constructor">Render_frame</span></code></td></tr><tr id="type-render_kind.Render_instruction" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_instruction" class="anchor"></a><code>| </code><code><span class="constructor">Render_instruction</span></code></td></tr><tr id="type-render_kind.Render_vars" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_vars" class="anchor"></a><code>| </code><code><span class="constructor">Render_vars</span></code></td></tr><tr id="type-render_kind.Render_vars_new" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_vars_new" class="anchor"></a><code>| </code><code><span class="constructor">Render_vars_new</span></code></td></tr><tr id="type-render_kind.Render_vars_old" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_vars_old" class="anchor"></a><code>| </code><code><span class="constructor">Render_vars_old</span></code></td></tr><tr id="type-render_kind.Render_inlining" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_inlining" class="anchor"></a><code>| </code><code><span class="constructor">Render_inlining</span></code></td></tr><tr id="type-render_kind.Render_ctrlflow" class="anchored"><td class="def constructor"><a href="#type-render_kind.Render_ctrlflow" class="anchor"></a><code>| </code><code><span class="constructor">Render_ctrlflow</span></code></td></tr></table></dt></dl><dl><dt class="spec value" id="val-render_colour"><a href="#val-render_colour" class="anchor"></a><code><span class="keyword">val</span> render_colour : <a href="index.html#type-render_kind">render_kind</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-render_class_name"><a href="#val-render_class_name" class="anchor"></a><code><span class="keyword">val</span> render_class_name : <a href="index.html#type-render_kind">render_kind</a> <span>&#45;&gt;</span> string</code></dt></dl><dl><dt class="spec type" id="type-html_idiom"><a href="#type-html_idiom" class="anchor"></a><code><span class="keyword">type</span> html_idiom</code><code> = </code><table class="variant"><tr id="type-html_idiom.HI_span" class="anchored"><td class="def constructor"><a href="#type-html_idiom.HI_span" class="anchor"></a><code>| </code><code><span class="constructor">HI_span</span></code></td></tr><tr id="type-html_idiom.HI_pre" class="anchored"><td class="def constructor"><a href="#type-html_idiom.HI_pre" class="anchor"></a><code>| </code><code><span class="constructor">HI_pre</span></code></td></tr><tr id="type-html_idiom.HI_classless_span" class="anchored"><td class="def constructor"><a href="#type-html_idiom.HI_classless_span" class="anchor"></a><code>| </code><code><span class="constructor">HI_classless_span</span></code></td></tr><tr id="type-html_idiom.HI_font" class="anchored"><td class="def constructor"><a href="#type-html_idiom.HI_font" class="anchor"></a><code>| </code><code><span class="constructor">HI_font</span></code></td></tr></table></dt></dl><dl><dt class="spec value" id="val-html_idiom"><a href="#val-html_idiom" class="anchor"></a><code><span class="keyword">val</span> html_idiom : <a href="index.html#type-html_idiom">html_idiom</a></code></dt><dt class="spec value" id="val-css"><a href="#val-css" class="anchor"></a><code><span class="keyword">val</span> css : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="index.html#type-render_kind">render_kind</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string</code></dt></dl><aside><p>pretty-print one instruction</p></aside><dl><dt class="spec value" id="val-last_frame_info"><a href="#val-last_frame_info" class="anchor"></a><code><span class="keyword">val</span> last_frame_info : <span>string Stdlib.ref</span></code></dt><dt class="spec value" id="val-last_var_info"><a href="#val-last_var_info" class="anchor"></a><code><span class="keyword">val</span> last_var_info : <span><span>string list</span> Stdlib.ref</span></code></dt><dt class="spec value" id="val-last_source_info"><a href="#val-last_source_info" class="anchor"></a><code><span class="keyword">val</span> last_source_info : <span>string Stdlib.ref</span></code></dt><dt class="spec value" id="val-pp_instruction_init"><a href="#val-pp_instruction_init" class="anchor"></a><code><span class="keyword">val</span> pp_instruction_init : unit <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-pp_instruction"><a href="#val-pp_instruction" class="anchor"></a><code><span class="keyword">val</span> pp_instruction : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../../Analyse__/ControlFlowTypes/index.html#type-instruction">Analyse__.ControlFlowTypes.instruction</a> <span>&#45;&gt;</span> string</code></dt></dl><aside><p>pretty-print test analysis</p></aside><dl><dt class="spec value" id="val-skylight"><a href="#val-skylight" class="anchor"></a><code><span class="keyword">val</span> skylight : unit <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-chunk_filename_whole"><a href="#val-chunk_filename_whole" class="anchor"></a><code><span class="keyword">val</span> chunk_filename_whole : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string * string</code></dt><dt class="spec value" id="val-chunk_filename_per_cu"><a href="#val-chunk_filename_per_cu" class="anchor"></a><code><span class="keyword">val</span> chunk_filename_per_cu : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> Dwarf.sdt_compilation_unit <span>&#45;&gt;</span> string * string</code></dt><dt class="spec value" id="val-wrap_chunks"><a href="#val-wrap_chunks" class="anchor"></a><code><span class="keyword">val</span> wrap_chunks : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * string)</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * string)</span> list</span></code></dt><dt class="spec value" id="val-whole_file_chunks"><a href="#val-whole_file_chunks" class="anchor"></a><code><span class="keyword">val</span> whole_file_chunks : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span> * string * string * <span class="type-var">'c</span>)</span> list</span> list</span> <span>&#45;&gt;</span> <span><span>(string * string * string)</span> list</span></code></dt><dt class="spec value" id="val-pp_instructions_ranged"><a href="#val-pp_instructions_ranged" class="anchor"></a><code><span class="keyword">val</span> pp_instructions_ranged : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> <span>(<a href="../Utils/index.html#type-addr">Utils.addr</a> * <a href="../Utils/index.html#type-addr">Utils.addr</a>)</span> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-chunks_of_ranged_cu"><a href="#val-chunks_of_ranged_cu" class="anchor"></a><code><span class="keyword">val</span> chunks_of_ranged_cu : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span>(<span>(<a href="../Utils/index.html#type-natural">Utils.natural</a> * <a href="../Utils/index.html#type-natural">Utils.natural</a>)</span> * Dwarf.sdt_compilation_unit)</span> <span>&#45;&gt;</span> string * <span><span>(string * string * string)</span> list</span></code></dt><dt class="spec value" id="val-wrap_body"><a href="#val-wrap_body" class="anchor"></a><code><span class="keyword">val</span> wrap_body : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <span>(string * string * string)</span> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-output_file"><a href="#val-output_file" class="anchor"></a><code><span class="keyword">val</span> output_file : <span>(string * string * string)</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-output_whole_file_files"><a href="#val-output_whole_file_files" class="anchor"></a><code><span class="keyword">val</span> output_whole_file_files : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span> * string * string * <span class="type-var">'c</span>)</span> list</span> list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-output_per_cu_files"><a href="#val-output_per_cu_files" class="anchor"></a><code><span class="keyword">val</span> output_per_cu_files : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span>(<a href="../Utils/index.html#type-natural">Utils.natural</a> * <a href="../Utils/index.html#type-natural">Utils.natural</a>)</span> * Dwarf.sdt_compilation_unit)</span> list</span> <span>&#45;&gt;</span> <span><span><span>(string * string * string * string)</span> list</span> list</span></code></dt><dt class="spec value" id="val-pp_test_analysis"><a href="#val-pp_test_analysis" class="anchor"></a><code><span class="keyword">val</span> pp_test_analysis : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> <a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span>&#45;&gt;</span> <a href="../../Analyse__/CollectedType/index.html#type-analysis">Analyse__.CollectedType.analysis</a> <span>&#45;&gt;</span> string</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Pp (read-dwarf.Analyse.Pp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Pp</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Pp</span></code></h1><p>render collected analysis data to text or css</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-render_kind"><a href="#type-render_kind" class="anchor"></a><code><span><span class="keyword">type</span> render_kind</span><span> = </span></code><ol><li id="type-render_kind.Render_symbol_star" class="def variant constructor anchored"><a href="#type-render_kind.Render_symbol_star" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_symbol_star</span></span></code></li><li id="type-render_kind.Render_symbol_nostar" class="def variant constructor anchored"><a href="#type-render_kind.Render_symbol_nostar" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_symbol_nostar</span></span></code></li><li id="type-render_kind.Render_source" class="def variant constructor anchored"><a href="#type-render_kind.Render_source" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_source</span></span></code></li><li id="type-render_kind.Render_frame" class="def variant constructor anchored"><a href="#type-render_kind.Render_frame" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_frame</span></span></code></li><li id="type-render_kind.Render_instruction" class="def variant constructor anchored"><a href="#type-render_kind.Render_instruction" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_instruction</span></span></code></li><li id="type-render_kind.Render_vars" class="def variant constructor anchored"><a href="#type-render_kind.Render_vars" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_vars</span></span></code></li><li id="type-render_kind.Render_vars_new" class="def variant constructor anchored"><a href="#type-render_kind.Render_vars_new" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_vars_new</span></span></code></li><li id="type-render_kind.Render_vars_old" class="def variant constructor anchored"><a href="#type-render_kind.Render_vars_old" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_vars_old</span></span></code></li><li id="type-render_kind.Render_inlining" class="def variant constructor anchored"><a href="#type-render_kind.Render_inlining" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_inlining</span></span></code></li><li id="type-render_kind.Render_ctrlflow" class="def variant constructor anchored"><a href="#type-render_kind.Render_ctrlflow" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_ctrlflow</span></span></code></li><li id="type-render_kind.Render_relocation" class="def variant constructor anchored"><a href="#type-render_kind.Render_relocation" class="anchor"></a><code><span>| </span><span><span class="constructor">Render_relocation</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-render_colour"><a href="#val-render_colour" class="anchor"></a><code><span><span class="keyword">val</span> render_colour : <span><a href="#type-render_kind">render_kind</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-render_class_name"><a href="#val-render_class_name" class="anchor"></a><code><span><span class="keyword">val</span> render_class_name : <span><a href="#type-render_kind">render_kind</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-html_idiom"><a href="#type-html_idiom" class="anchor"></a><code><span><span class="keyword">type</span> html_idiom</span><span> = </span></code><ol><li id="type-html_idiom.HI_span" class="def variant constructor anchored"><a href="#type-html_idiom.HI_span" class="anchor"></a><code><span>| </span><span><span class="constructor">HI_span</span></span></code></li><li id="type-html_idiom.HI_pre" class="def variant constructor anchored"><a href="#type-html_idiom.HI_pre" class="anchor"></a><code><span>| </span><span><span class="constructor">HI_pre</span></span></code></li><li id="type-html_idiom.HI_classless_span" class="def variant constructor anchored"><a href="#type-html_idiom.HI_classless_span" class="anchor"></a><code><span>| </span><span><span class="constructor">HI_classless_span</span></span></code></li><li id="type-html_idiom.HI_font" class="def variant constructor anchored"><a href="#type-html_idiom.HI_font" class="anchor"></a><code><span>| </span><span><span class="constructor">HI_font</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-html_idiom"><a href="#val-html_idiom" class="anchor"></a><code><span><span class="keyword">val</span> html_idiom : <a href="#type-html_idiom">html_idiom</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-css"><a href="#val-css" class="anchor"></a><code><span><span class="keyword">val</span> css : <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-render_kind">render_kind</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><p>pretty-print one instruction</p><div class="odoc-spec"><div class="spec value anchored" id="val-last_frame_info"><a href="#val-last_frame_info" class="anchor"></a><code><span><span class="keyword">val</span> last_frame_info : <span>string <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-last_var_info"><a href="#val-last_var_info" class="anchor"></a><code><span><span class="keyword">val</span> last_var_info : <span><span>string list</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-last_source_info"><a href="#val-last_source_info" class="anchor"></a><code><span><span class="keyword">val</span> last_source_info : <span>string <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_instruction_init"><a href="#val-pp_instruction_init" class="anchor"></a><code><span><span class="keyword">val</span> pp_instruction_init : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_instruction"><a href="#val-pp_instruction" class="anchor"></a><code><span><span class="keyword">val</span> pp_instruction : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.ControlFlowTypes.instruction</span> <span class="arrow">&#45;&gt;</span></span>
+  string</span></code></div></div><p>pretty-print test analysis</p><div class="odoc-spec"><div class="spec value anchored" id="val-skylight"><a href="#val-skylight" class="anchor"></a><code><span><span class="keyword">val</span> skylight : <span>unit <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-chunk_filename_whole"><a href="#val-chunk_filename_whole" class="anchor"></a><code><span><span class="keyword">val</span> chunk_filename_whole : <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-chunk_filename_per_cu"><a href="#val-chunk_filename_per_cu" class="anchor"></a><code><span><span class="keyword">val</span> chunk_filename_per_cu : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Dwarf</span>.sdt_compilation_unit <span class="arrow">&#45;&gt;</span></span>
+  string * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-wrap_chunks"><a href="#val-wrap_chunks" class="anchor"></a><code><span><span class="keyword">val</span> wrap_chunks : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * string)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * string)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-whole_file_chunks"><a href="#val-whole_file_chunks" class="anchor"></a><code><span><span class="keyword">val</span> whole_file_chunks : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span> * string * string * <span class="type-var">'c</span>)</span> list</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * string * string)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_instructions_ranged"><a href="#val-pp_instructions_ranged" class="anchor"></a><code><span><span class="keyword">val</span> pp_instructions_ranged : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../Utils/index.html#type-addr">Utils.addr</a> * <span class="xref-unresolved">Sym_ocaml</span>.Num.t)</span> <span class="arrow">&#45;&gt;</span></span>
+  string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-chunks_of_ranged_cu"><a href="#val-chunks_of_ranged_cu" class="anchor"></a><code><span><span class="keyword">val</span> chunks_of_ranged_cu : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span>(<a href="../Utils/index.html#type-natural">Utils.natural</a> * <a href="../Utils/index.html#type-natural">Utils.natural</a>)</span> * <span class="xref-unresolved">Dwarf</span>.sdt_compilation_unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  string * <span><span>(string * string * string)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-wrap_body"><a href="#val-wrap_body" class="anchor"></a><code><span><span class="keyword">val</span> wrap_body : <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(string * string * string)</span> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-output_file"><a href="#val-output_file" class="anchor"></a><code><span><span class="keyword">val</span> output_file : <span><span>(string * string * string)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-output_whole_file_files"><a href="#val-output_whole_file_files" class="anchor"></a><code><span><span class="keyword">val</span> output_whole_file_files : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span> * string * string * <span class="type-var">'c</span>)</span> list</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-output_per_cu_files"><a href="#val-output_per_cu_files" class="anchor"></a><code><span><span class="keyword">val</span> output_per_cu_files : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span>(<a href="../Utils/index.html#type-natural">Utils.natural</a> * <a href="../Utils/index.html#type-natural">Utils.natural</a>)</span> * <span class="xref-unresolved">Dwarf</span>.sdt_compilation_unit)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(string * string * string * string)</span> list</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_test_analysis"><a href="#val-pp_test_analysis" class="anchor"></a><code><span><span class="keyword">val</span> pp_test_analysis : 
+  <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../ElfTypes/index.html#type-test">ElfTypes.test</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Analyse__.CollectedType.analysis</span> <span class="arrow">&#45;&gt;</span></span>
+  string</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/Types/index.html b/doc/html/read-dwarf/Analyse/Types/index.html
index 442fddb6..f2ec21c7 100644
--- a/doc/html/read-dwarf/Analyse/Types/index.html
+++ b/doc/html/read-dwarf/Analyse/Types/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Types (read-dwarf.Analyse.Types)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Types</nav><h1>Module <code>Analyse.Types</code></h1><p>types shared between analyse* and the read-dwarf top-level</p></header><dl><dt class="spec type" id="type-ppmode"><a href="#type-ppmode" class="anchor"></a><code><span class="keyword">type</span> ppmode</code><code> = </code><table class="variant"><tr id="type-ppmode.Ascii" class="anchored"><td class="def constructor"><a href="#type-ppmode.Ascii" class="anchor"></a><code>| </code><code><span class="constructor">Ascii</span></code></td></tr><tr id="type-ppmode.Html" class="anchored"><td class="def constructor"><a href="#type-ppmode.Html" class="anchor"></a><code>| </code><code><span class="constructor">Html</span></code></td></tr></table></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Types (read-dwarf.Analyse.Types)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Types</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Types</span></code></h1><p>types shared between analyse* and the read-dwarf top-level</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-ppmode"><a href="#type-ppmode" class="anchor"></a><code><span><span class="keyword">type</span> ppmode</span><span> = </span></code><ol><li id="type-ppmode.Ascii" class="def variant constructor anchored"><a href="#type-ppmode.Ascii" class="anchor"></a><code><span>| </span><span><span class="constructor">Ascii</span></span></code></li><li id="type-ppmode.Html" class="def variant constructor anchored"><a href="#type-ppmode.Html" class="anchor"></a><code><span>| </span><span><span class="constructor">Html</span></span></code></li></ol></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/Utils/index.html b/doc/html/read-dwarf/Analyse/Utils/index.html
index 580f1f56..2d1db3b3 100644
--- a/doc/html/read-dwarf/Analyse/Utils/index.html
+++ b/doc/html/read-dwarf/Analyse/Utils/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Utils (read-dwarf.Analyse.Utils)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Utils</nav><h1>Module <code>Analyse.Utils</code></h1><p>Miscellaneous types and utility functions used throughout the analyse code</p></header><dl><dt class="spec type" id="type-natural"><a href="#type-natural" class="anchor"></a><code><span class="keyword">type</span> natural</code><code> = Nat_big_num.num</code></dt><dd><p>TODO: Maybe just use Z.t everywhere (it's shorter)</p></dd></dl><dl><dt class="spec type" id="type-addr"><a href="#type-addr" class="anchor"></a><code><span class="keyword">type</span> addr</code><code> = <a href="index.html#type-natural">natural</a></code></dt><dd><p>machine address</p></dd></dl><dl><dt class="spec value" id="val-pp_addr"><a href="#val-pp_addr" class="anchor"></a><code><span class="keyword">val</span> pp_addr : <a href="index.html#type-natural">natural</a> <span>&#45;&gt;</span> string</code></dt></dl><dl><dt class="spec type" id="type-index"><a href="#type-index" class="anchor"></a><code><span class="keyword">type</span> index</code><code> = int</code></dt><dd><p>index into instruction-indexed arrays</p></dd></dl><dl><dt class="spec value" id="val-measure_time"><a href="#val-measure_time" class="anchor"></a><code><span class="keyword">val</span> measure_time : bool</code></dt><dt class="spec value" id="val-time"><a href="#val-time" class="anchor"></a><code><span class="keyword">val</span> time : string <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>Print the time this function call took. The string is just for the printed message</p></dd></dl><dl><dt class="spec value" id="val-read_file_lines"><a href="#val-read_file_lines" class="anchor"></a><code><span class="keyword">val</span> read_file_lines : string <span>&#45;&gt;</span> <span><span>(<span>string array</span>, string)</span> Stdlib.result</span></code></dt><dd><p>Read all lines of a file</p></dd></dl><dl><dt class="spec value" id="val-html_escape"><a href="#val-html_escape" class="anchor"></a><code><span class="keyword">val</span> html_escape : string <span>&#45;&gt;</span> string</code></dt><dd><p>escape HTML</p></dd></dl><dl><dt class="spec value" id="val-esc"><a href="#val-esc" class="anchor"></a><code><span class="keyword">val</span> esc : <a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-sys_command"><a href="#val-sys_command" class="anchor"></a><code><span class="keyword">val</span> sys_command : string <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Utils (read-dwarf.Analyse.Utils)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Analyse</a> &#x00BB; Utils</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse.Utils</span></code></h1><p>Miscellaneous types and utility functions used throughout the analyse code</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-natural"><a href="#type-natural" class="anchor"></a><code><span><span class="keyword">type</span> natural</span><span> = <a href="../../Utils/Sym/index.html#type-t">Utils.Sym.t</a></span></code></div><div class="spec-doc"><p>TODO: Maybe just use Z.t everywhere (it's shorter)</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-addr"><a href="#type-addr" class="anchor"></a><code><span><span class="keyword">type</span> addr</span><span> = <a href="#type-natural">natural</a></span></code></div><div class="spec-doc"><p>machine address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_addr"><a href="#val-pp_addr" class="anchor"></a><code><span><span class="keyword">val</span> pp_addr : <span><a href="#type-natural">natural</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-index"><a href="#type-index" class="anchor"></a><code><span><span class="keyword">type</span> index</span><span> = int</span></code></div><div class="spec-doc"><p>index into instruction-indexed arrays</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-measure_time"><a href="#val-measure_time" class="anchor"></a><code><span><span class="keyword">val</span> measure_time : bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-time"><a href="#val-time" class="anchor"></a><code><span><span class="keyword">val</span> time : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Print the time this function call took. The string is just for the printed message</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_file_lines"><a href="#val-read_file_lines" class="anchor"></a><code><span><span class="keyword">val</span> read_file_lines : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>string array</span>, string)</span> <span class="xref-unresolved">Stdlib</span>.result</span></span></code></div><div class="spec-doc"><p>Read all lines of a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-html_escape"><a href="#val-html_escape" class="anchor"></a><code><span><span class="keyword">val</span> html_escape : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>escape HTML</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-esc"><a href="#val-esc" class="anchor"></a><code><span><span class="keyword">val</span> esc : <span><a href="../Types/index.html#type-ppmode">Types.ppmode</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sys_command"><a href="#val-sys_command" class="anchor"></a><code><span><span class="keyword">val</span> sys_command : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Analyse/index.html b/doc/html/read-dwarf/Analyse/index.html
index 01080a89..adcfd724 100644
--- a/doc/html/read-dwarf/Analyse/index.html
+++ b/doc/html/read-dwarf/Analyse/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Analyse (read-dwarf.Analyse)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Analyse</nav><h1>Module <code>Analyse</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="index.html#module-Base">Base</a></code></span></summary><dl><dt class="spec value" id="val-process_file"><a href="#val-process_file" class="anchor"></a><code><span class="keyword">val</span> process_file : unit <span>&#45;&gt;</span> unit</code></dt></dl></details></div></div></div><div class="spec module" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span class="keyword">module</span> <a href="Base/index.html">Base</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec module" id="module-Collected"><a href="#module-Collected" class="anchor"></a><code><span class="keyword">module</span> <a href="Collected/index.html">Collected</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>collect the various test analysis data</p></dd></dl><dl><dt class="spec module" id="module-DwarfLineInfo"><a href="#module-DwarfLineInfo" class="anchor"></a><code><span class="keyword">module</span> <a href="DwarfLineInfo/index.html">DwarfLineInfo</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>post-process DWARF source line info</p></dd></dl><div class="spec module" id="module-Elf"><a href="#module-Elf" class="anchor"></a><code><span class="keyword">module</span> <a href="Elf/index.html">Elf</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec module" id="module-ElfTypes"><a href="#module-ElfTypes" class="anchor"></a><code><span class="keyword">module</span> <a href="ElfTypes/index.html">ElfTypes</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>type of collected ELF-file data from linksem</p></dd></dl><div class="spec module" id="module-Globals"><a href="#module-Globals" class="anchor"></a><code><span class="keyword">module</span> <a href="Globals/index.html">Globals</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Pp"><a href="#module-Pp" class="anchor"></a><code><span class="keyword">module</span> <a href="Pp/index.html">Pp</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec module" id="module-Types"><a href="#module-Types" class="anchor"></a><code><span class="keyword">module</span> <a href="Types/index.html">Types</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>types shared between analyse* and the read-dwarf top-level</p></dd></dl><dl><dt class="spec module" id="module-Utils"><a href="#module-Utils" class="anchor"></a><code><span class="keyword">module</span> <a href="Utils/index.html">Utils</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Miscellaneous types and utility functions used throughout the analyse code</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Analyse (read-dwarf.Analyse)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Analyse</nav><header class="odoc-preamble"><h1>Module <code><span>Analyse</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="Base/index.html">Base</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-process_file"><a href="#val-process_file" class="anchor"></a><code><span><span class="keyword">val</span> process_file : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Base/index.html">Base</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-CallGraph"><a href="#module-CallGraph" class="anchor"></a><code><span><span class="keyword">module</span> <a href="CallGraph/index.html">CallGraph</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>compute call-graph</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Collected"><a href="#module-Collected" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Collected/index.html">Collected</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>collect the various test analysis data</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-DwarfLineInfo"><a href="#module-DwarfLineInfo" class="anchor"></a><code><span><span class="keyword">module</span> <a href="DwarfLineInfo/index.html">DwarfLineInfo</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>post-process DWARF source line info</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Elf"><a href="#module-Elf" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Elf/index.html">Elf</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>pp symbol map</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ElfTypes"><a href="#module-ElfTypes" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ElfTypes/index.html">ElfTypes</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>type of collected ELF-file data from linksem</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Globals"><a href="#module-Globals" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Globals/index.html">Globals</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Pp"><a href="#module-Pp" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Pp/index.html">Pp</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>render collected analysis data to text or css</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Types"><a href="#module-Types" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Types/index.html">Types</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>types shared between analyse* and the read-dwarf top-level</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Utils"><a href="#module-Utils" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Utils/index.html">Utils</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Miscellaneous types and utility functions used throughout the analyse code</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Arch/index.html b/doc/html/read-dwarf/Arch/index.html
index 41a73a6b..5a3f86de 100644
--- a/doc/html/read-dwarf/Arch/index.html
+++ b/doc/html/read-dwarf/Arch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Arch (read-dwarf.Arch)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Arch</nav><h1>Module <code>Arch</code></h1><p>This module adds some code that is related to the Architecture specific modules but is in itself architecture independent.</p></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../Sig/index.html">Sig</a></code></span></summary><dl><dt class="spec type" id="type-func_api"><a href="#type-func_api" class="anchor"></a><code><span class="keyword">type</span> func_api</code><code> = </code><code>{</code><table class="record"><tr id="type-func_api.args" class="anchored"><td class="def field"><a href="#type-func_api.args" class="anchor"></a><code>args : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> list</span>;</code></td></tr><tr id="type-func_api.ret" class="anchored"><td class="def field"><a href="#type-func_api.ret" class="anchor"></a><code>ret : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> option</span>;</code></td></tr></table><code>}</code></dt><dd><p>Describe the C API of a function</p></dd></dl><dl><dt class="spec type" id="type-func_abi"><a href="#type-func_abi" class="anchor"></a><code><span class="keyword">type</span> func_abi</code><code> = </code><code>{</code><table class="record"><tr id="type-func_abi.init" class="anchored"><td class="def field"><a href="#type-func_abi.init" class="anchor"></a><code>init : <a href="../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../State/index.html#type-t">State.t</a>;</code></td><td class="doc"><p>Gives the initial state for verifying the function, from a given global register state. Only global registers are kept.</p></td></tr></table><code>}</code></dt><dd><p>Describe the ABI of a function</p><p>This is a record because I expect to add many other fields later.</p></dd></dl><dl><dt class="spec type" id="type-dwarf_reg_map"><a href="#type-dwarf_reg_map" class="anchor"></a><code><span class="keyword">type</span> dwarf_reg_map</code><code> = <span><a href="../State/Reg/index.html#type-t">State.Reg.t</a> array</span></code></dt><dd><p>The map of dwarf register: Which register number map to which ISA register</p></dd></dl><dl><dt class="spec value" id="val-supports"><a href="#val-supports" class="anchor"></a><code><span class="keyword">val</span> supports : <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tells if this Arch module supports this architecture</p></dd></dl><dl><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>If this arch module <a href="index.html#val-supports"><code>supports</code></a> the architecture, then initialize read-dwarf state using this architecture</p></dd></dl><dl><dt class="spec value" id="val-initialized"><a href="#val-initialized" class="anchor"></a><code><span class="keyword">val</span> initialized : unit <span>&#45;&gt;</span> <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> option</span></code></dt><dd><p>Return <code>Some(arch)</code> is the loaded arch is <code>arch</code> and <code>None</code> if nothing is loaded yet.</p></dd></dl><dl><dt class="spec value" id="val-module_name"><a href="#val-module_name" class="anchor"></a><code><span class="keyword">val</span> module_name : string</code></dt><dd><p>The name of the arch module. Must be the name of the module i.e. <code>Config.arch_module</code></p></dd></dl><dl><dt class="spec value" id="val-loaded_name"><a href="#val-loaded_name" class="anchor"></a><code><span class="keyword">val</span> loaded_name : string</code></dt><dd><p>For dynamic arch module, the name of the dynamically loaded module. Otherwise <a href="index.html#val-module_name"><code>module_name</code></a></p></dd></dl><dl><dt class="spec value" id="val-address_size"><a href="#val-address_size" class="anchor"></a><code><span class="keyword">val</span> address_size : int</code></dt><dd><p>The true size of addresses for memory operation</p></dd></dl><dl><dt class="spec value" id="val-dwarf_reg_map"><a href="#val-dwarf_reg_map" class="anchor"></a><code><span class="keyword">val</span> dwarf_reg_map : unit <span>&#45;&gt;</span> <a href="index.html#type-dwarf_reg_map">dwarf_reg_map</a></code></dt><dd><p>Get the register map of the architecture</p></dd></dl><dl><dt class="spec value" id="val-is_local"><a href="#val-is_local" class="anchor"></a><code><span class="keyword">val</span> is_local : <a href="../State/Reg/index.html#type-t">State.Reg.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if a register is local for the ABI</p></dd></dl><dl><dt class="spec value" id="val-nop"><a href="#val-nop" class="anchor"></a><code><span class="keyword">val</span> nop : unit <span>&#45;&gt;</span> <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></code></dt><dd><p>Give the opcode of the nop instruction (For Sail/Isla initialisation</p></dd></dl><dl><dt class="spec value" id="val-get_abi"><a href="#val-get_abi" class="anchor"></a><code><span class="keyword">val</span> get_abi : <a href="index.html#type-func_api">func_api</a> <span>&#45;&gt;</span> <a href="index.html#type-func_abi">func_abi</a></code></dt><dd><p>Give the ABI of a function from it's C API</p></dd></dl><dl><dt class="spec value" id="val-pc"><a href="#val-pc" class="anchor"></a><code><span class="keyword">val</span> pc : unit <span>&#45;&gt;</span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></code></dt><dd><p>Give the register index for the program counter</p></dd></dl><dl><dt class="spec value" id="val-sp"><a href="#val-sp" class="anchor"></a><code><span class="keyword">val</span> sp : unit <span>&#45;&gt;</span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></code></dt><dd><p>Give the register index for the stack pointer</p></dd></dl><dl><dt class="spec value" id="val-assemble_to_elf"><a href="#val-assemble_to_elf" class="anchor"></a><code><span class="keyword">val</span> assemble_to_elf : string <span>&#45;&gt;</span> string</code></dt><dd><p>Take an instruction string and give the name of an temporary ELF file created that contains the instruction at symbol instr.</p></dd></dl><dl><dt class="spec value" id="val-split_into_instrs"><a href="#val-split_into_instrs" class="anchor"></a><code><span class="keyword">val</span> split_into_instrs : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> list</span></code></dt><dd><p>Split a byte-sequence into a list of instructions.</p></dd></dl><dl><dt class="spec value" id="val-is_ret"><a href="#val-is_ret" class="anchor"></a><code><span class="keyword">val</span> is_ret : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if an instruction is a return instruction.</p></dd></dl><dl><dt class="spec value" id="val-is_cmp"><a href="#val-is_cmp" class="anchor"></a><code><span class="keyword">val</span> is_cmp : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><span>(<a href="../State/Reg/index.html#type-t">State.Reg.t</a> * <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a>)</span> option</span></code></dt><dd><p>Tell if an instruction is a compare instruction. Returns <code>Some (reg,bv)</code> where the contents of <code>reg</code> are compared against the value <code>bv</code> if it is and <code>None</code> if not.</p></dd></dl><dl><dt class="spec value" id="val-is_bl"><a href="#val-is_bl" class="anchor"></a><code><span class="keyword">val</span> is_bl : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> option</span></code></dt><dd><p>Tell if an instruction is an (unconditional) branch on immediate with link instructions. Returns <code>Some bv</code> where <code>bv</code> is the offset (from the address of this instruction, in the range +/-128MB) that is branched to if it is and <code>None</code> if not.</p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-ensure_loaded"><a href="#val-ensure_loaded" class="anchor"></a><code><span class="keyword">val</span> ensure_loaded : <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Ensure that the right architecture type is loaded</p></dd></dl><dl><dt class="spec value" id="val-pp_api"><a href="#val-pp_api" class="anchor"></a><code><span class="keyword">val</span> pp_api : <a href="index.html#type-func_api">func_api</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : unit <span>&#45;&gt;</span> <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a></code></dt><dd><p>Get the initialized architecture type. Fails (<code>Failure</code>) if not architecture was loaded</p></dd></dl><dl><dt class="spec value" id="val-get_config"><a href="#val-get_config" class="anchor"></a><code><span class="keyword">val</span> get_config : unit <span>&#45;&gt;</span> <a href="../Config__File/ArchConf/index.html#type-t">Config.File.ArchConf.t</a></code></dt><dd><p>Get the configuration for the initialized architecture</p></dd></dl><dl><dt class="spec value" id="val-get_isla_config"><a href="#val-get_isla_config" class="anchor"></a><code><span class="keyword">val</span> get_isla_config : unit <span>&#45;&gt;</span> <a href="../Config__File/ArchConf/Isla/index.html#type-t">Config.File.ArchConf.Isla.t</a></code></dt><dd><p>Get the Isla configuration for the initialized architecture</p></dd></dl><dl><dt class="spec value" id="val-load_elf_arch"><a href="#val-load_elf_arch" class="anchor"></a><code><span class="keyword">val</span> load_elf_arch : <a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Load the architecture of this <a href="../Elf/File/index.html"><code>File</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Arch (read-dwarf.Arch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Arch</nav><header class="odoc-preamble"><h1>Module <code><span>Arch</span></code></h1><p>This module adds some code that is related to the Architecture specific modules but is in itself architecture independent.</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../Sig/index.html">Sig</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-func_api"><a href="#type-func_api" class="anchor"></a><code><span><span class="keyword">type</span> func_api</span><span> = <a href="../Sig/index.html#type-func_api">Sig.func_api</a></span><span> = </span><span>{</span></code><ol><li id="type-func_api.args" class="def record field anchored"><a href="#type-func_api.args" class="anchor"></a><code><span>args : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> list</span>;</span></code></li><li id="type-func_api.ret" class="def record field anchored"><a href="#type-func_api.ret" class="anchor"></a><code><span>ret : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> option</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Describe the C API of a function</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-func_abi"><a href="#type-func_abi" class="anchor"></a><code><span><span class="keyword">type</span> func_abi</span><span> = <a href="../Sig/index.html#type-func_abi">Sig.func_abi</a></span><span> = </span><span>{</span></code><ol><li id="type-func_abi.init" class="def record field anchored"><a href="#type-func_abi.init" class="anchor"></a><code><span>init : <span><a href="../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../State/index.html#type-t">State.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Gives the initial state for verifying the function, from a given global register state. Only global registers are kept.</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Describe the ABI of a function</p><p>This is a record because I expect to add many other fields later.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-dwarf_reg_map"><a href="#type-dwarf_reg_map" class="anchor"></a><code><span><span class="keyword">type</span> dwarf_reg_map</span><span> = <span><a href="../State/Reg/index.html#type-t">State.Reg.t</a> array</span></span></code></div><div class="spec-doc"><p>The map of dwarf register: Which register number map to which ISA register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-supports"><a href="#val-supports" class="anchor"></a><code><span><span class="keyword">val</span> supports : <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tells if this Arch module supports this architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>If this arch module <a href="#val-supports"><code>supports</code></a> the architecture, then initialize read-dwarf state using this architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-initialized"><a href="#val-initialized" class="anchor"></a><code><span><span class="keyword">val</span> initialized : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> option</span></span></code></div><div class="spec-doc"><p>Return <code>Some(arch)</code> is the loaded arch is <code>arch</code> and <code>None</code> if nothing is loaded yet.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-module_name"><a href="#val-module_name" class="anchor"></a><code><span><span class="keyword">val</span> module_name : string</span></code></div><div class="spec-doc"><p>The name of the arch module. Must be the name of the module i.e. <code>Config.arch_module</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-loaded_name"><a href="#val-loaded_name" class="anchor"></a><code><span><span class="keyword">val</span> loaded_name : string</span></code></div><div class="spec-doc"><p>For dynamic arch module, the name of the dynamically loaded module. Otherwise <a href="#val-module_name"><code>module_name</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-address_size"><a href="#val-address_size" class="anchor"></a><code><span><span class="keyword">val</span> address_size : int</span></code></div><div class="spec-doc"><p>The true size of addresses for memory operation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dwarf_reg_map"><a href="#val-dwarf_reg_map" class="anchor"></a><code><span><span class="keyword">val</span> dwarf_reg_map : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-dwarf_reg_map">dwarf_reg_map</a></span></code></div><div class="spec-doc"><p>Get the register map of the architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_local"><a href="#val-is_local" class="anchor"></a><code><span><span class="keyword">val</span> is_local : <span><a href="../State/Reg/index.html#type-t">State.Reg.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if a register is local for the ABI</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nop"><a href="#val-nop" class="anchor"></a><code><span><span class="keyword">val</span> nop : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></span></code></div><div class="spec-doc"><p>Give the opcode of the nop instruction (For Sail/Isla initialisation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_abi"><a href="#val-get_abi" class="anchor"></a><code><span><span class="keyword">val</span> get_abi : <span><a href="#type-func_api">func_api</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-func_abi">func_abi</a></span></code></div><div class="spec-doc"><p>Give the ABI of a function from it's C API</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pc"><a href="#val-pc" class="anchor"></a><code><span><span class="keyword">val</span> pc : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></span></code></div><div class="spec-doc"><p>Give the register index for the program counter</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sp"><a href="#val-sp" class="anchor"></a><code><span><span class="keyword">val</span> sp : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></span></code></div><div class="spec-doc"><p>Give the register index for the stack pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assemble_to_elf"><a href="#val-assemble_to_elf" class="anchor"></a><code><span><span class="keyword">val</span> assemble_to_elf : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Take an instruction string and give the name of an temporary ELF file created that contains the instruction at symbol instr.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_into_instrs"><a href="#val-split_into_instrs" class="anchor"></a><code><span><span class="keyword">val</span> split_into_instrs : <span><a href="../Elf/Symbol/index.html#type-data">Elf.Symbol.data</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Elf/Symbol/index.html#type-data">Elf.Symbol.data</a> list</span></span></code></div><div class="spec-doc"><p>Split a byte-sequence into a list of instructions.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_ret"><a href="#val-is_ret" class="anchor"></a><code><span><span class="keyword">val</span> is_ret : <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if an instruction is a return instruction.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_cmp"><a href="#val-is_cmp" class="anchor"></a><code><span><span class="keyword">val</span> is_cmp : <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../State/Reg/index.html#type-t">State.Reg.t</a> * <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a>)</span> option</span></span></code></div><div class="spec-doc"><p>Tell if an instruction is a compare instruction. Returns <code>Some (reg,bv)</code> where the contents of <code>reg</code> are compared against the value <code>bv</code> if it is and <code>None</code> if not.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_bl"><a href="#val-is_bl" class="anchor"></a><code><span><span class="keyword">val</span> is_bl : <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> option</span></span></code></div><div class="spec-doc"><p>Tell if an instruction is an (unconditional) branch on immediate with link instructions. Returns <code>Some bv</code> where <code>bv</code> is the offset (from the address of this instruction, in the range +/-128MB) that is branched to if it is and <code>None</code> if not.</p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_loaded"><a href="#val-ensure_loaded" class="anchor"></a><code><span><span class="keyword">val</span> ensure_loaded : <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Ensure that the right architecture type is loaded</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_api"><a href="#val-pp_api" class="anchor"></a><code><span><span class="keyword">val</span> pp_api : <span><a href="#type-func_api">func_api</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a></span></code></div><div class="spec-doc"><p>Get the initialized architecture type. Fails (<code>Failure</code>) if not architecture was loaded</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_config"><a href="#val-get_config" class="anchor"></a><code><span><span class="keyword">val</span> get_config : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Config/File/ArchConf/index.html#type-t">Config.File.ArchConf.t</a></span></code></div><div class="spec-doc"><p>Get the configuration for the initialized architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_isla_config"><a href="#val-get_isla_config" class="anchor"></a><code><span><span class="keyword">val</span> get_isla_config : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Config/File/ArchConf/Isla/index.html#type-t">Config.File.ArchConf.Isla.t</a></span></code></div><div class="spec-doc"><p>Get the Isla configuration for the initialized architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-load_elf_arch"><a href="#val-load_elf_arch" class="anchor"></a><code><span><span class="keyword">val</span> load_elf_arch : <span><a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Load the architecture of this <a href="../Elf/File/index.html"><code>Elf.File</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Architecture.html b/doc/html/read-dwarf/Architecture.html
index 21f73096..88dcf8f5 100644
--- a/doc/html/read-dwarf/Architecture.html
+++ b/doc/html/read-dwarf/Architecture.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Architecture (read-dwarf.Architecture)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; Architecture</nav><h1 id="architecture"><a href="#architecture" class="anchor"></a>Architecture</h1><p>Here I will present how to describe a symbolic state of a specific architecture in read-dwarf.</p><p>The architectures are listed by the <a href="Config__/Arch/index.html#type-t"><code>Config.Arch.t</code></a> enumeration. Not all architectures in the enumeration have the full support, but an architecture must be in the enumeration to be supported. Feel free to add others. This enumeration is used everywhere to refer to various architectures.</p><nav class="toc"><ul><li><a href="#architecture-as-a-virtual-module">Architecture as a Virtual Module</a></li><li><a href="#architectural-features">Architectural features</a></li><li><a href="#representation-of-the-architectural-state">Representation of the architectural state</a></li></ul></nav></header><h2 id="architecture-as-a-virtual-module"><a href="#architecture-as-a-virtual-module" class="anchor"></a>Architecture as a Virtual Module</h2><p>read-dwarf uses <a href="https://dune.readthedocs.io/en/stable/variants.html">Dune's virtual modules</a> to parameterise on the architecture, though currently there is only one supported: <code>aarch64</code>. Any executable (including inline test executables) must therefore be given valid implementation of the virtual module.</p><p>The signature for the architecture is in <a href="Sig/index.html"><code>Sig</code></a>, the only module in a Dune library called <code>sig</code>; an implementation is in <code>src/arch/aarch64/sig.ml</code>, as part of a library called <code>sig_aarch64</code>. Because <a href="Arch/index.html"><code>Arch</code></a> relies on <a href="Sig/index.html"><code>Sig</code></a>, it too becomes virtual, and so does every module that uses <a href="Arch/index.html"><code>Arch</code></a>. See <code>src/isla/dune</code> to see how to integrate this for running inline tests, otherwise simply add <code>sig_aarch64</code> (or any other implementation module) to the <code>libraries</code> Dune stanza when defining an executable (see <code>src/bin/dune</code> and <code>src/tests/dune</code> for examples).</p><h2 id="architectural-features"><a href="#architectural-features" class="anchor"></a>Architectural features</h2><p>A lot of architecture specific things, like the function call ABI, the physical memory size and some other things are in the <a href="Arch/index.html"><code>Arch</code></a> module. However some things are not. For example the list of registers and their SMT types (<a href="Ast/index.html#type-ty"><code>Ast.ty</code></a>) are managed by the <a href="State/Reg/index.html"><code>State.Reg</code></a> module. This is because the register list is not statically hard-coded. It is deduced at run-time from isla, which means that we do not need to maintain a list of system register anywhere. Obviously the <a href="Arch/index.html"><code>Arch</code></a> module need to know about some register to manage the ABI, so those registers will be introduced by <a href="Arch/index.html"><code>Arch</code></a>, but all the other register are only introduced if an instruction touching them is used. This means that if a system register is never used, it's exactly the same as if doesn't exist for read-dwarf.</p><h2 id="representation-of-the-architectural-state"><a href="#representation-of-the-architectural-state" class="anchor"></a>Representation of the architectural state</h2><p>Full architectural state are represented by value of type <a href="State/index.html#type-t"><code>State.t</code></a>, those value are symbolic and actually represent set of concrete state. This is explained in <a href="State/index.html"><code>State</code></a> it self.</p><p>All state are derived from other state using <a href="State/index.html#val-copy"><code>State.copy</code></a>, apart from the first one which should be <a href="Run/Init/index.html#val-state"><code>Run.Init.state</code></a>. When calling that function, Isla will be called on a dummy instruction to get the isla initialization sequence. Currently the <a href="Run/Init/index.html"><code>Run.Init</code></a> module just considers the Isla start state as the initial state. To get the initial state at function entry, only must get the ABI of the function (of type <a href="Arch/index.html#type-func_abi"><code>Arch.func_abi</code></a>) and then call <a href="Arch/index.html#type-func_abi.init"><code>Arch.func_abi.init</code></a></p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Architecture (read-dwarf.Architecture)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; Architecture</nav><header class="odoc-preamble"><h1 id="architecture"><a href="#architecture" class="anchor"></a>Architecture</h1><p>Here I will present how to describe a symbolic state of a specific architecture in read-dwarf.</p><p>The architectures are listed by the <a href="Config/Arch/index.html#type-t"><code>Config.Arch.t</code></a> enumeration. Not all architectures in the enumeration have the full support, but an architecture must be in the enumeration to be supported. Feel free to add others. This enumeration is used everywhere to refer to various architectures.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#architecture-as-a-virtual-module">Architecture as a Virtual Module</a></li><li><a href="#architectural-features">Architectural features</a></li><li><a href="#representation-of-the-architectural-state">Representation of the architectural state</a></li></ul></nav></div><div class="odoc-content"><h2 id="architecture-as-a-virtual-module"><a href="#architecture-as-a-virtual-module" class="anchor"></a>Architecture as a Virtual Module</h2><p>read-dwarf uses <a href="https://dune.readthedocs.io/en/stable/variants.html">Dune's virtual modules</a> to parameterise on the architecture, though currently there is only one supported: <code>aarch64</code>. Any executable (including inline test executables) must therefore be given valid implementation of the virtual module.</p><p>The signature for the architecture is in <a href="Sig/index.html"><code>Sig</code></a>, the only module in a Dune library called <code>sig</code>; an implementation is in <code>src/arch/aarch64/sig.ml</code>, as part of a library called <code>sig_aarch64</code>. Because <a href="Arch/index.html"><code>Arch</code></a> relies on <a href="Sig/index.html"><code>Sig</code></a>, it too becomes virtual, and so does every module that uses <a href="Arch/index.html"><code>Arch</code></a>. See <code>src/isla/dune</code> to see how to integrate this for running inline tests, otherwise simply add <code>sig_aarch64</code> (or any other implementation module) to the <code>libraries</code> Dune stanza when defining an executable (see <code>src/bin/dune</code> and <code>src/tests/dune</code> for examples).</p><h2 id="architectural-features"><a href="#architectural-features" class="anchor"></a>Architectural features</h2><p>A lot of architecture specific things, like the function call ABI, the physical memory size and some other things are in the <a href="Arch/index.html"><code>Arch</code></a> module. However some things are not. For example the list of registers and their SMT types (<a href="Ast/index.html#type-ty"><code>Ast.ty</code></a>) are managed by the <a href="State/Reg/index.html"><code>State.Reg</code></a> module. This is because the register list is not statically hard-coded. It is deduced at run-time from isla, which means that we do not need to maintain a list of system register anywhere. Obviously the <a href="Arch/index.html"><code>Arch</code></a> module need to know about some register to manage the ABI, so those registers will be introduced by <a href="Arch/index.html"><code>Arch</code></a>, but all the other register are only introduced if an instruction touching them is used. This means that if a system register is never used, it's exactly the same as if doesn't exist for read-dwarf.</p><h2 id="representation-of-the-architectural-state"><a href="#representation-of-the-architectural-state" class="anchor"></a>Representation of the architectural state</h2><p>Full architectural state are represented by value of type <a href="State/index.html#type-t"><code>State.t</code></a>, those value are symbolic and actually represent set of concrete state. This is explained in <a href="State/index.html"><code>State</code></a> it self.</p><p>All state are derived from other state using <a href="State/index.html#val-copy"><code>State.copy</code></a>, apart from the first one which should be <a href="Run/Init/index.html#val-state"><code>Run.Init.state</code></a>. When calling that function, Isla will be called on a dummy instruction to get the isla initialization sequence. Currently the <a href="Run/Init/index.html"><code>Run.Init</code></a> module just considers the Isla start state as the initial state. To get the initial state at function entry, only must get the ABI of the function (of type <a href="Arch/index.html#type-func_abi"><code>Arch.func_abi</code></a>) and then call <a href="Arch/index.html#type-func_abi.init"><code>Arch.func_abi.init</code></a></p></div></body></html>
diff --git a/doc/html/read-dwarf/Ast/Base/Size/index.html b/doc/html/read-dwarf/Ast/Base/Size/index.html
index a230760a..6bfe302a 100644
--- a/doc/html/read-dwarf/Ast/Base/Size/index.html
+++ b/doc/html/read-dwarf/Ast/Base/Size/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Size (read-dwarf.Ast.Base.Size)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Ast</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Size</nav><h1>Module <code>Base.Size</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../AstGen/Def/index.html#module-Size">AstGen.Def.Size</a></code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.B8" class="anchored"><td class="def constructor"><a href="#type-t.B8" class="anchor"></a><code>| </code><code><span class="constructor">B8</span></code></td></tr><tr id="type-t.B16" class="anchored"><td class="def constructor"><a href="#type-t.B16" class="anchor"></a><code>| </code><code><span class="constructor">B16</span></code></td></tr><tr id="type-t.B32" class="anchored"><td class="def constructor"><a href="#type-t.B32" class="anchor"></a><code>| </code><code><span class="constructor">B32</span></code></td></tr><tr id="type-t.B64" class="anchored"><td class="def constructor"><a href="#type-t.B64" class="anchor"></a><code>| </code><code><span class="constructor">B64</span></code></td></tr></table></dt><dd><p>The possible sizes for memory accesses. It may be necessary to add <code>B128</code> at some point</p></dd></dl><dl><dt class="spec value" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span class="keyword">val</span> of_bytes : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a size value from a valid size in byte</p></dd></dl><dl><dt class="spec value" id="val-of_bits"><a href="#val-of_bits" class="anchor"></a><code><span class="keyword">val</span> of_bits : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a size value from a valid size in bits</p></dd></dl><dl><dt class="spec value" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span class="keyword">val</span> to_bytes : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the byte size corresponding to that value</p></dd></dl><dl><dt class="spec value" id="val-to_bits"><a href="#val-to_bits" class="anchor"></a><code><span class="keyword">val</span> to_bits : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the bits size corresponding to that value</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-pp_bytes"><a href="#val-pp_bytes" class="anchor"></a><code><span class="keyword">val</span> pp_bytes : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty-print a size as just the byte number</p></dd></dl><dl><dt class="spec value" id="val-pp_bits"><a href="#val-pp_bits" class="anchor"></a><code><span class="keyword">val</span> pp_bits : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty print a size at &quot;16bits&quot; for example</p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-to_bv"><a href="#val-to_bv" class="anchor"></a><code><span class="keyword">val</span> to_bv : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../index.html#type-ty">ty</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Size (read-dwarf.Ast.Base.Size)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Ast</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Size</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Size</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../../AstGen/Def/Size/index.html">AstGen.Def.Size</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <a href="../../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a></span><span> = </span></code><ol><li id="type-t.B8" class="def variant constructor anchored"><a href="#type-t.B8" class="anchor"></a><code><span>| </span><span><span class="constructor">B8</span></span></code></li><li id="type-t.B16" class="def variant constructor anchored"><a href="#type-t.B16" class="anchor"></a><code><span>| </span><span><span class="constructor">B16</span></span></code></li><li id="type-t.B32" class="def variant constructor anchored"><a href="#type-t.B32" class="anchor"></a><code><span>| </span><span><span class="constructor">B32</span></span></code></li><li id="type-t.B64" class="def variant constructor anchored"><a href="#type-t.B64" class="anchor"></a><code><span>| </span><span><span class="constructor">B64</span></span></code></li><li id="type-t.B128" class="def variant constructor anchored"><a href="#type-t.B128" class="anchor"></a><code><span>| </span><span><span class="constructor">B128</span></span></code></li></ol></div><div class="spec-doc"><p>The possible sizes for memory accesses.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span><span class="keyword">val</span> of_bytes : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a size value from a valid size in byte</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bits"><a href="#val-of_bits" class="anchor"></a><code><span><span class="keyword">val</span> of_bits : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a size value from a valid size in bits</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span><span class="keyword">val</span> to_bytes : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the byte size corresponding to that value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bits"><a href="#val-to_bits" class="anchor"></a><code><span><span class="keyword">val</span> to_bits : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the bits size corresponding to that value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bytes"><a href="#val-pp_bytes" class="anchor"></a><code><span><span class="keyword">val</span> pp_bytes : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty-print a size as just the byte number</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bits"><a href="#val-pp_bits" class="anchor"></a><code><span><span class="keyword">val</span> pp_bits : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a size at &quot;16bits&quot; for example</p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bv"><a href="#val-to_bv" class="anchor"></a><code><span><span class="keyword">val</span> to_bv : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../index.html#type-ty">ty</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Ast/Base/index.html b/doc/html/read-dwarf/Ast/Base/index.html
index 76ecf51c..0c9483d0 100644
--- a/doc/html/read-dwarf/Ast/Base/index.html
+++ b/doc/html/read-dwarf/Ast/Base/index.html
@@ -1,7 +1,58 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Ast.Base)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Ast</a> &#x00BB; Base</nav><h1>Module <code>Ast.Base</code></h1><p>The main module to use the AST of expression and SMT operation for a more generic overview of the AST, see <a href="../../SymbolicExpressions.html"><code>SymbolicExpressions</code></a>.</p><nav class="toc"><ul><li><a href="#size">Size</a></li><li><a href="#parsing">Parsing</a></li><li><a href="#analysers">Analysers</a></li><li><a href="#destr">Destructors</a></li><li><a href="#expectors">Expectors</a></li><li><a href="#construtors">Construtors</a></li><li><a href="#comparisons">Comparisons</a></li></ul></nav></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../AstGen/index.html#module-Def">AstGen.Def</a></code></span></summary><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../AstGen/index.html#module-Ott">AstGen.Ott</a></code></span></summary><aside><p>warning: the backend selected ignores the file structure informations</p></aside><dl><dt class="spec type" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span class="keyword">type</span> bvar</code><code> = string</code></dt><dd><p>syntax</p></dd></dl><dl><dt class="spec type" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span class="keyword">type</span> flag</code><code> = string</code></dt><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = int * int</code></dt><dt class="spec type" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span class="keyword">type</span> <span>'m binmem</span></code><code> = </code><table class="variant"><tr id="type-binmem.Select" class="anchored"><td class="def constructor"><a href="#type-binmem.Select" class="anchor"></a><code>| </code><code><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-binmem.Store" class="anchored"><td class="def constructor"><a href="#type-binmem.Store" class="anchor"></a><code>| </code><code><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr></table></dt><dt class="spec type" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span class="keyword">type</span> bvarith</code><code> = </code><table class="variant"><tr id="type-bvarith.Bvuremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvuremi</span></code></td></tr><tr id="type-bvarith.Bvsremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsremi</span></code></td></tr><tr id="type-bvarith.Bvsmodi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmodi</span></code></td></tr><tr id="type-bvarith.Bvnand" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnand" class="anchor"></a><code>| </code><code><span class="constructor">Bvnand</span></code></td></tr><tr id="type-bvarith.Bvnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvnor</span></code></td></tr><tr id="type-bvarith.Bvxnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxnor</span></code></td></tr><tr id="type-bvarith.Bvsub" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsub" class="anchor"></a><code>| </code><code><span class="constructor">Bvsub</span></code></td></tr><tr id="type-bvarith.Bvudiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvudiv</span></code></td></tr><tr id="type-bvarith.Bvudivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvudivi</span></code></td></tr><tr id="type-bvarith.Bvsdiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdiv</span></code></td></tr><tr id="type-bvarith.Bvsdivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdivi</span></code></td></tr><tr id="type-bvarith.Bvurem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvurem" class="anchor"></a><code>| </code><code><span class="constructor">Bvurem</span></code></td></tr><tr id="type-bvarith.Bvsrem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code>| </code><code><span class="constructor">Bvsrem</span></code></td></tr><tr id="type-bvarith.Bvsmod" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmod</span></code></td></tr><tr id="type-bvarith.Bvshl" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvshl" class="anchor"></a><code>| </code><code><span class="constructor">Bvshl</span></code></td></tr><tr id="type-bvarith.Bvlshr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code>| </code><code><span class="constructor">Bvlshr</span></code></td></tr><tr id="type-bvarith.Bvashr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvashr" class="anchor"></a><code>| </code><code><span class="constructor">Bvashr</span></code></td></tr></table></dt><dt class="spec type" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span class="keyword">type</span> bvcomp</code><code> = </code><table class="variant"><tr id="type-bvcomp.Bvult" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvult" class="anchor"></a><code>| </code><code><span class="constructor">Bvult</span></code></td></tr><tr id="type-bvcomp.Bvslt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code>| </code><code><span class="constructor">Bvslt</span></code></td></tr><tr id="type-bvcomp.Bvule" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvule" class="anchor"></a><code>| </code><code><span class="constructor">Bvule</span></code></td></tr><tr id="type-bvcomp.Bvsle" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code>| </code><code><span class="constructor">Bvsle</span></code></td></tr><tr id="type-bvcomp.Bvuge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code>| </code><code><span class="constructor">Bvuge</span></code></td></tr><tr id="type-bvcomp.Bvsge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code>| </code><code><span class="constructor">Bvsge</span></code></td></tr><tr id="type-bvcomp.Bvugt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code>| </code><code><span class="constructor">Bvugt</span></code></td></tr><tr id="type-bvcomp.Bvsgt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code>| </code><code><span class="constructor">Bvsgt</span></code></td></tr></table></dt><dt class="spec type" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span class="keyword">type</span> bvmanyarith</code><code> = </code><table class="variant"><tr id="type-bvmanyarith.Bvand" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code>| </code><code><span class="constructor">Bvand</span></code></td></tr><tr id="type-bvmanyarith.Bvor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code>| </code><code><span class="constructor">Bvor</span></code></td></tr><tr id="type-bvmanyarith.Bvxor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxor</span></code></td></tr><tr id="type-bvmanyarith.Bvadd" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code>| </code><code><span class="constructor">Bvadd</span></code></td></tr><tr id="type-bvmanyarith.Bvmul" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code>| </code><code><span class="constructor">Bvmul</span></code></td></tr></table></dt><dt class="spec type" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span class="keyword">type</span> unop</code><code> = </code><table class="variant"><tr id="type-unop.Not" class="anchored"><td class="def constructor"><a href="#type-unop.Not" class="anchor"></a><code>| </code><code><span class="constructor">Not</span></code></td></tr><tr id="type-unop.Bvnot" class="anchored"><td class="def constructor"><a href="#type-unop.Bvnot" class="anchor"></a><code>| </code><code><span class="constructor">Bvnot</span></code></td></tr><tr id="type-unop.Bvredand" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredand" class="anchor"></a><code>| </code><code><span class="constructor">Bvredand</span></code></td></tr><tr id="type-unop.Bvredor" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredor" class="anchor"></a><code>| </code><code><span class="constructor">Bvredor</span></code></td></tr><tr id="type-unop.Bvneg" class="anchored"><td class="def constructor"><a href="#type-unop.Bvneg" class="anchor"></a><code>| </code><code><span class="constructor">Bvneg</span></code></td></tr><tr id="type-unop.Extract" class="anchored"><td class="def constructor"><a href="#type-unop.Extract" class="anchor"></a><code>| </code><code><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-unop.ZeroExtend" class="anchored"><td class="def constructor"><a href="#type-unop.ZeroExtend" class="anchor"></a><code>| </code><code><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-unop.SignExtend" class="anchored"><td class="def constructor"><a href="#type-unop.SignExtend" class="anchor"></a><code>| </code><code><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span class="keyword">type</span> <span>'m binop</span></code><code> = </code><table class="variant"><tr id="type-binop.Binmem" class="anchored"><td class="def constructor"><a href="#type-binop.Binmem" class="anchor"></a><code>| </code><code><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binmem">binmem</a></span></code></td></tr><tr id="type-binop.Eq" class="anchored"><td class="def constructor"><a href="#type-binop.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span></code></td></tr><tr id="type-binop.Bvarith" class="anchored"><td class="def constructor"><a href="#type-binop.Bvarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="index.html#type-bvarith">bvarith</a></code></td></tr><tr id="type-binop.Bvcomp" class="anchored"><td class="def constructor"><a href="#type-binop.Bvcomp" class="anchor"></a><code>| </code><code><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="index.html#type-bvcomp">bvcomp</a></code></td></tr></table></dt><dt class="spec type" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span class="keyword">type</span> manyop</code><code> = </code><table class="variant"><tr id="type-manyop.And" class="anchored"><td class="def constructor"><a href="#type-manyop.And" class="anchor"></a><code>| </code><code><span class="constructor">And</span></code></td></tr><tr id="type-manyop.Or" class="anchored"><td class="def constructor"><a href="#type-manyop.Or" class="anchor"></a><code>| </code><code><span class="constructor">Or</span></code></td></tr><tr id="type-manyop.Bvmanyarith" class="anchored"><td class="def constructor"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="index.html#type-bvmanyarith">bvmanyarith</a></code></td></tr><tr id="type-manyop.Concat" class="anchored"><td class="def constructor"><a href="#type-manyop.Concat" class="anchor"></a><code>| </code><code><span class="constructor">Concat</span></code></td></tr></table></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></code><code> = </code><table class="variant"><tr id="type-exp.Var" class="anchored"><td class="def constructor"><a href="#type-exp.Var" class="anchor"></a><code>| </code><code><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bound" class="anchored"><td class="def constructor"><a href="#type-exp.Bound" class="anchor"></a><code>| </code><code><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bits" class="anchored"><td class="def constructor"><a href="#type-exp.Bits" class="anchor"></a><code>| </code><code><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bool" class="anchored"><td class="def constructor"><a href="#type-exp.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Enum" class="anchored"><td class="def constructor"><a href="#type-exp.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Unop" class="anchored"><td class="def constructor"><a href="#type-exp.Unop" class="anchor"></a><code>| </code><code><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Binop" class="anchored"><td class="def constructor"><a href="#type-exp.Binop" class="anchor"></a><code>| </code><code><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Manyop" class="anchored"><td class="def constructor"><a href="#type-exp.Manyop" class="anchor"></a><code>| </code><code><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Vec" class="anchored"><td class="def constructor"><a href="#type-exp.Vec" class="anchor"></a><code>| </code><code><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Ite" class="anchored"><td class="def constructor"><a href="#type-exp.Ite" class="anchor"></a><code>| </code><code><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Let" class="anchored"><td class="def constructor"><a href="#type-exp.Let" class="anchor"></a><code>| </code><code><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span>)</span> list</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> <span>'m ty</span></code><code> = </code><table class="variant"><tr id="type-ty.Ty_Mem" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Mem" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-ty.Ty_Bool" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Bool</span></code></td></tr><tr id="type-ty.Ty_BitVec" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code>| </code><code><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Enum" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Array" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Array" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr></table></dt><dt class="spec type" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></code><code> = </code><table class="variant"><tr id="type-smt.DeclareConst" class="anchored"><td class="def constructor"><a href="#type-smt.DeclareConst" class="anchor"></a><code>| </code><code><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr><tr id="type-smt.DefineConst" class="anchored"><td class="def constructor"><a href="#type-smt.DefineConst" class="anchor"></a><code>| </code><code><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Assert" class="anchored"><td class="def constructor"><a href="#type-smt.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Simplify" class="anchored"><td class="def constructor"><a href="#type-smt.Simplify" class="anchor"></a><code>| </code><code><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></code></td></tr><tr id="type-smt.Push" class="anchored"><td class="def constructor"><a href="#type-smt.Push" class="anchor"></a><code>| </code><code><span class="constructor">Push</span></code></td></tr><tr id="type-smt.Pop" class="anchored"><td class="def constructor"><a href="#type-smt.Pop" class="anchor"></a><code>| </code><code><span class="constructor">Pop</span></code></td></tr><tr id="type-smt.GetVersion" class="anchored"><td class="def constructor"><a href="#type-smt.GetVersion" class="anchor"></a><code>| </code><code><span class="constructor">GetVersion</span></code></td></tr><tr id="type-smt.CheckSat" class="anchored"><td class="def constructor"><a href="#type-smt.CheckSat" class="anchor"></a><code>| </code><code><span class="constructor">CheckSat</span></code></td></tr><tr id="type-smt.Exit" class="anchored"><td class="def constructor"><a href="#type-smt.Exit" class="anchor"></a><code>| </code><code><span class="constructor">Exit</span></code></td></tr></table></dt><dt class="spec type" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></code><code> = </code><table class="variant"><tr id="type-smt_ans.Error" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Error" class="anchor"></a><code>| </code><code><span class="constructor">Error</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Version" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Version" class="anchor"></a><code>| </code><code><span class="constructor">Version</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Sat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Sat" class="anchor"></a><code>| </code><code><span class="constructor">Sat</span></code></td></tr><tr id="type-smt_ans.Unsat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsat" class="anchor"></a><code>| </code><code><span class="constructor">Unsat</span></code></td></tr><tr id="type-smt_ans.Unknown" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unknown" class="anchor"></a><code>| </code><code><span class="constructor">Unknown</span></code></td></tr><tr id="type-smt_ans.Unsupported" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code>| </code><code><span class="constructor">Unsupported</span></code></td></tr><tr id="type-smt_ans.Exp" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Exp" class="anchor"></a><code>| </code><code><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr></table></dt></dl><aside><p>auxiliary functions on the new list types</p></aside><aside><p>library functions</p></aside><aside><p>subrules</p></aside><aside><p>auxiliary functions</p></aside><aside><p>free variables</p></aside><aside><p>substitutions</p></aside><aside><p>context application</p></aside><aside><p>definitions</p></aside></details></div></div></div><dl><dt class="spec type" id="type-no"><a href="#type-no" class="anchor"></a><code><span class="keyword">type</span> no</code><code> = </code><table class="variant"></table></dt><dd><p>Generic empty type. This kind of type is explained <a href="http://caml.inria.fr/pub/docs/manual-ocaml/emptyvariants.html">here</a>. In particular, when this type appear in a match case, the match case can contain a refutation pattern <code>.</code> to indicate that this impossible.</p><p>A refutation pattern also work with higher-level constructors, for example in this case:</p><pre><code class="ml">type a = A of int | B of no * int
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Ast.Base)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Ast</a> &#x00BB; Base</nav><header class="odoc-preamble"><h1>Module <code><span>Ast.Base</span></code></h1><p>The main module to use the AST of expression and SMT operation for a more generic overview of the AST, see <a href="../../SymbolicExpressions.html"><code>SymbolicExpressions</code></a>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#size">Size</a></li><li><a href="#parsing">Parsing</a></li><li><a href="#analysers">Analysers</a></li><li><a href="#destr">Destructors</a></li><li><a href="#expectors">Expectors</a></li><li><a href="#construtors">Construtors</a></li><li><a href="#comparisons">Comparisons</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../AstGen/Def/index.html">AstGen.Def</a> <span class="keyword">end</span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../AstGen/Ott/index.html">AstGen.Ott</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span><span class="keyword">type</span> bvar</span><span> = string</span></code></div><div class="spec-doc"><p>syntax</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span><span class="keyword">type</span> flag</span><span> = string</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span><span class="keyword">type</span> bvmanyarith</span><span> = <a href="../../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a></span><span> = </span></code><ol><li id="type-bvmanyarith.Bvand" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvand</span></span></code></li><li id="type-bvmanyarith.Bvor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvor</span></span></code></li><li id="type-bvmanyarith.Bvxor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxor</span></span></code></li><li id="type-bvmanyarith.Bvadd" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvadd</span></span></code></li><li id="type-bvmanyarith.Bvmul" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmul</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binmem</span></span><span> = <span><span class="type-var">'m</span> <a href="../../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span></span><span> = </span></code><ol><li id="type-binmem.Select" class="def variant constructor anchored"><a href="#type-binmem.Select" class="anchor"></a><code><span>| </span><span><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-binmem.Store" class="def variant constructor anchored"><a href="#type-binmem.Store" class="anchor"></a><code><span>| </span><span><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span><span class="keyword">type</span> bvcomp</span><span> = <a href="../../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a></span><span> = </span></code><ol><li id="type-bvcomp.Bvult" class="def variant constructor anchored"><a href="#type-bvcomp.Bvult" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvult</span></span></code></li><li id="type-bvcomp.Bvslt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvslt</span></span></code></li><li id="type-bvcomp.Bvule" class="def variant constructor anchored"><a href="#type-bvcomp.Bvule" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvule</span></span></code></li><li id="type-bvcomp.Bvsle" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsle</span></span></code></li><li id="type-bvcomp.Bvuge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuge</span></span></code></li><li id="type-bvcomp.Bvsge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsge</span></span></code></li><li id="type-bvcomp.Bvugt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvugt</span></span></code></li><li id="type-bvcomp.Bvsgt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsgt</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span><span class="keyword">type</span> bvarith</span><span> = <a href="../../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a></span><span> = </span></code><ol><li id="type-bvarith.Bvuremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuremi</span></span></code></li><li id="type-bvarith.Bvsremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsremi</span></span></code></li><li id="type-bvarith.Bvsmodi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmodi</span></span></code></li><li id="type-bvarith.Bvnand" class="def variant constructor anchored"><a href="#type-bvarith.Bvnand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnand</span></span></code></li><li id="type-bvarith.Bvnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnor</span></span></code></li><li id="type-bvarith.Bvxnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxnor</span></span></code></li><li id="type-bvarith.Bvsub" class="def variant constructor anchored"><a href="#type-bvarith.Bvsub" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsub</span></span></code></li><li id="type-bvarith.Bvudiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudiv</span></span></code></li><li id="type-bvarith.Bvudivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudivi</span></span></code></li><li id="type-bvarith.Bvsdiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdiv</span></span></code></li><li id="type-bvarith.Bvsdivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdivi</span></span></code></li><li id="type-bvarith.Bvurem" class="def variant constructor anchored"><a href="#type-bvarith.Bvurem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvurem</span></span></code></li><li id="type-bvarith.Bvsrem" class="def variant constructor anchored"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsrem</span></span></code></li><li id="type-bvarith.Bvsmod" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmod</span></span></code></li><li id="type-bvarith.Bvshl" class="def variant constructor anchored"><a href="#type-bvarith.Bvshl" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvshl</span></span></code></li><li id="type-bvarith.Bvlshr" class="def variant constructor anchored"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvlshr</span></span></code></li><li id="type-bvarith.Bvashr" class="def variant constructor anchored"><a href="#type-bvarith.Bvashr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvashr</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span><span class="keyword">type</span> manyop</span><span> = <a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a></span><span> = </span></code><ol><li id="type-manyop.And" class="def variant constructor anchored"><a href="#type-manyop.And" class="anchor"></a><code><span>| </span><span><span class="constructor">And</span></span></code></li><li id="type-manyop.Or" class="def variant constructor anchored"><a href="#type-manyop.Or" class="anchor"></a><code><span>| </span><span><span class="constructor">Or</span></span></code></li><li id="type-manyop.Bvmanyarith" class="def variant constructor anchored"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="#type-bvmanyarith">bvmanyarith</a></span></code></li><li id="type-manyop.Concat" class="def variant constructor anchored"><a href="#type-manyop.Concat" class="anchor"></a><code><span>| </span><span><span class="constructor">Concat</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binop</span></span><span> = <span><span class="type-var">'m</span> <a href="../../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span></span><span> = </span></code><ol><li id="type-binop.Binmem" class="def variant constructor anchored"><a href="#type-binop.Binmem" class="anchor"></a><code><span>| </span><span><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binmem">binmem</a></span></span></code></li><li id="type-binop.Eq" class="def variant constructor anchored"><a href="#type-binop.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span></span></code></li><li id="type-binop.Bvarith" class="def variant constructor anchored"><a href="#type-binop.Bvarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="#type-bvarith">bvarith</a></span></code></li><li id="type-binop.Bvcomp" class="def variant constructor anchored"><a href="#type-binop.Bvcomp" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="#type-bvcomp">bvcomp</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span><span class="keyword">type</span> unop</span><span> = <a href="../../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a></span><span> = </span></code><ol><li id="type-unop.Not" class="def variant constructor anchored"><a href="#type-unop.Not" class="anchor"></a><code><span>| </span><span><span class="constructor">Not</span></span></code></li><li id="type-unop.Bvnot" class="def variant constructor anchored"><a href="#type-unop.Bvnot" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnot</span></span></code></li><li id="type-unop.Bvredand" class="def variant constructor anchored"><a href="#type-unop.Bvredand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredand</span></span></code></li><li id="type-unop.Bvredor" class="def variant constructor anchored"><a href="#type-unop.Bvredor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredor</span></span></code></li><li id="type-unop.Bvneg" class="def variant constructor anchored"><a href="#type-unop.Bvneg" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvneg</span></span></code></li><li id="type-unop.Extract" class="def variant constructor anchored"><a href="#type-unop.Extract" class="anchor"></a><code><span>| </span><span><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-unop.ZeroExtend" class="def variant constructor anchored"><a href="#type-unop.ZeroExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</span></code></li><li id="type-unop.SignExtend" class="def variant constructor anchored"><a href="#type-unop.SignExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></span><span> = </span></code><ol><li id="type-exp.Var" class="def variant constructor anchored"><a href="#type-exp.Var" class="anchor"></a><code><span>| </span><span><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bound" class="def variant constructor anchored"><a href="#type-exp.Bound" class="anchor"></a><code><span>| </span><span><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bits" class="def variant constructor anchored"><a href="#type-exp.Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bool" class="def variant constructor anchored"><a href="#type-exp.Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></span></code></li><li id="type-exp.Enum" class="def variant constructor anchored"><a href="#type-exp.Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Unop" class="def variant constructor anchored"><a href="#type-exp.Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Binop" class="def variant constructor anchored"><a href="#type-exp.Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Manyop" class="def variant constructor anchored"><a href="#type-exp.Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Vec" class="def variant constructor anchored"><a href="#type-exp.Vec" class="anchor"></a><code><span>| </span><span><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Ite" class="def variant constructor anchored"><a href="#type-exp.Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Let" class="def variant constructor anchored"><a href="#type-exp.Let" class="anchor"></a><code><span>| </span><span><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>)</span> list</span>
+  * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m ty</span></span><span> = <span><span class="type-var">'m</span> <a href="../../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span></span><span> = </span></code><ol><li id="type-ty.Ty_Mem" class="def variant constructor anchored"><a href="#type-ty.Ty_Mem" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-ty.Ty_Bool" class="def variant constructor anchored"><a href="#type-ty.Ty_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Bool</span></span></code></li><li id="type-ty.Ty_BitVec" class="def variant constructor anchored"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Enum" class="def variant constructor anchored"><a href="#type-ty.Ty_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Array" class="def variant constructor anchored"><a href="#type-ty.Ty_Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span></span><span> = </span></code><ol><li id="type-smt.DeclareConst" class="def variant constructor anchored"><a href="#type-smt.DeclareConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li><li id="type-smt.DefineConst" class="def variant constructor anchored"><a href="#type-smt.DefineConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Assert" class="def variant constructor anchored"><a href="#type-smt.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Simplify" class="def variant constructor anchored"><a href="#type-smt.Simplify" class="anchor"></a><code><span>| </span><span><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></span></code></li><li id="type-smt.Push" class="def variant constructor anchored"><a href="#type-smt.Push" class="anchor"></a><code><span>| </span><span><span class="constructor">Push</span></span></code></li><li id="type-smt.Pop" class="def variant constructor anchored"><a href="#type-smt.Pop" class="anchor"></a><code><span>| </span><span><span class="constructor">Pop</span></span></code></li><li id="type-smt.GetVersion" class="def variant constructor anchored"><a href="#type-smt.GetVersion" class="anchor"></a><code><span>| </span><span><span class="constructor">GetVersion</span></span></code></li><li id="type-smt.CheckSat" class="def variant constructor anchored"><a href="#type-smt.CheckSat" class="anchor"></a><code><span>| </span><span><span class="constructor">CheckSat</span></span></code></li><li id="type-smt.Exit" class="def variant constructor anchored"><a href="#type-smt.Exit" class="anchor"></a><code><span>| </span><span><span class="constructor">Exit</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span></span><span> = </span></code><ol><li id="type-smt_ans.Error" class="def variant constructor anchored"><a href="#type-smt_ans.Error" class="anchor"></a><code><span>| </span><span><span class="constructor">Error</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Version" class="def variant constructor anchored"><a href="#type-smt_ans.Version" class="anchor"></a><code><span>| </span><span><span class="constructor">Version</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Sat" class="def variant constructor anchored"><a href="#type-smt_ans.Sat" class="anchor"></a><code><span>| </span><span><span class="constructor">Sat</span></span></code></li><li id="type-smt_ans.Unsat" class="def variant constructor anchored"><a href="#type-smt_ans.Unsat" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsat</span></span></code></li><li id="type-smt_ans.Unknown" class="def variant constructor anchored"><a href="#type-smt_ans.Unknown" class="anchor"></a><code><span>| </span><span><span class="constructor">Unknown</span></span></code></li><li id="type-smt_ans.Unsupported" class="def variant constructor anchored"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsupported</span></span></code></li><li id="type-smt_ans.Exp" class="def variant constructor anchored"><a href="#type-smt_ans.Exp" class="anchor"></a><code><span>| </span><span><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li></ol></div></div><p>auxiliary functions on the new list types</p><p>library functions</p><p>subrules</p><p>auxiliary functions</p><p>free variables</p><p>substitutions</p><p>context application</p><p>definitions</p></details></div><div class="odoc-spec"><div class="spec type anchored" id="type-no"><a href="#type-no" class="anchor"></a><code><span><span class="keyword">type</span> no</span><span> = <a href="../../AstGen/Def/index.html#type-no">AstGen.Def.no</a></span><span> = </span><span>|</span></code></div><div class="spec-doc"><p>Generic empty type. This kind of type is explained <a href="http://caml.inria.fr/pub/docs/manual-ocaml/emptyvariants.html">here</a>. In particular, when this type appear in a match case, the match case can contain a refutation pattern <code>.</code> to indicate that this impossible.</p><p>A refutation pattern also work with higher-level constructors, for example in this case:</p><pre class="language-ocaml"><code>type a = A of int | B of no * int
 let f : a -&gt; int = function
   | A i -&gt; i
-  | B _ -&gt; .</code></pre><p>It also work in product types:</p><pre><code class="ml">let f : no * int -&gt; unit = function _ -&gt; . </code></pre><p>However it doesn't work for sum types: the <code>no</code> type need to appear directly in the pattern:</p><pre><code class="ml">type complex_empty = A of no | B of no
+  | B _ -&gt; .</code></pre><p>It also work in product types:</p><pre class="language-ocaml"><code> let f : no * int -&gt; unit = function _ -&gt; . </code></pre><p>However it doesn't work for sum types: the <code>no</code> type need to appear directly in the pattern:</p><pre class="language-ocaml"><code>type complex_empty = A of no | B of no
 let f : complex_empty = function _ -&gt; . (* does not compile *)
-let f : complex_empty = function A _ | B _ -&gt; . (* compiles *)</code></pre><p>In case this behavior is needed, there <a href="../index.html#destr"><span>Destructors</span></a> in <a href="../index.html"><code>Ast</code></a>. See this section to see how they are used.</p></dd></dl><dl><dt class="spec type" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span class="keyword">type</span> loc</code><code> = Stdlib.Lexing.position</code></dt><dd><p><a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Lexing.html#TYPEposition"><code>Lexing.position</code></a></p></dd></dl><dl><dt class="spec type" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span class="keyword">type</span> lrng</code><code> = Isla_lang.AST.lrng</code></dt><dd><p>The type of an expression range. This imported from Isla to avoid having two incompatible types.</p><p>This represent a range in a source file, so generally this is a pair of <a href="index.html#type-loc"><code>loc</code></a>, but it may also be <code>Unknown</code>.</p></dd></dl><div class="spec module" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span class="keyword">module</span> Size = <a href="../../AstGen/Def/index.html#module-Size">AstGen.Def.Size</a></code></div><dl><dt class="spec type" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span class="keyword">type</span> rexp</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-exp">exp</a></span></code></dt><dd><p>Raw expression coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rty"><a href="#type-rty" class="anchor"></a><code><span class="keyword">type</span> rty</code><code> = <span><a href="Size/index.html#type-t">Size.t</a> <a href="index.html#type-ty">ty</a></span></code></dt><dd><p>Raw type coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span class="keyword">type</span> rsmt</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-smt">smt</a></span></code></dt><dd><p>Raw SMT command coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt_ans"><a href="#type-rsmt_ans" class="anchor"></a><code><span class="keyword">type</span> rsmt_ans</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-smt_ans">smt_ans</a></span></code></dt><dd><p>Raw SMT answer coming out of the parser</p></dd></dl></details></div></div></div><section><header><h2 id="size"><a href="#size" class="anchor"></a>Size</h2></header><div class="spec module" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span class="keyword">module</span> <a href="Size/index.html">Size</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div></section><section><header><h2 id="parsing"><a href="#parsing" class="anchor"></a>Parsing</h2></header><div class="spec module" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span class="keyword">module</span> Parser = <a href="../../AstGen/index.html#module-Parser">AstGen.Parser</a></code></div><div class="spec module" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span class="keyword">module</span> Lexer = <a href="../../AstGen/index.html#module-Lexer">AstGen.Lexer</a></code></div><dl><dt class="spec value" id="val-unknown"><a href="#val-unknown" class="anchor"></a><code><span class="keyword">val</span> unknown : Isla_lang.AST.lrng</code></dt><dt class="spec value" id="val-loc"><a href="#val-loc" class="anchor"></a><code><span class="keyword">val</span> loc : Stdlib.Lexing.position <span>&#45;&gt;</span> PPrint.document</code></dt></dl><dl><dt class="spec exception" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla parsing error</p></dd></dl><dl><dt class="spec exception" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">LexError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla lexing error</p></dd></dl><dl><dt class="spec type" id="type-lexbuf"><a href="#type-lexbuf" class="anchor"></a><code><span class="keyword">type</span> lexbuf</code><code> = Stdlib.Lexing.lexbuf</code></dt><dt class="spec type" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span class="keyword">type</span> lexer</code><code> = <a href="index.html#type-lexbuf">lexbuf</a> <span>&#45;&gt;</span> <a href="../../AstGen/Parser/index.html#type-token">Parser.token</a></code></dt><dt class="spec type" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span class="keyword">type</span> <span>'a parser</span></code><code> = <a href="index.html#type-lexer">lexer</a> <span>&#45;&gt;</span> <a href="index.html#type-lexbuf">lexbuf</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec value" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span class="keyword">val</span> parse : <span><span class="type-var">'a</span> <a href="index.html#type-parser">parser</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="index.html#type-lexbuf">lexbuf</a>)</span> <span>&#45;&gt;</span> <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-from_string"><a href="#val-from_string" class="anchor"></a><code><span class="keyword">val</span> from_string : string <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf</code></dt><dt class="spec value" id="val-from_channel"><a href="#val-from_channel" class="anchor"></a><code><span class="keyword">val</span> from_channel : Stdlib.in_channel <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf</code></dt><dt class="spec value" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span class="keyword">val</span> parse_exp_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span><span>(<a href="../../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></code></dt><dd><p>Parse a single Isla expression from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span class="keyword">val</span> parse_exp_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <span><span>(<a href="../../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></code></dt><dd><p>Parse a single Isla expression from a channel</p></dd></dl><dl><dt class="spec value" id="val-parse_smt_ans_string"><a href="#val-parse_smt_ans_string" class="anchor"></a><code><span class="keyword">val</span> parse_smt_ans_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="../../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></code></dt><dd><p>Parse a single Isla expression from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_smt_ans_channel"><a href="#val-parse_smt_ans_channel" class="anchor"></a><code><span class="keyword">val</span> parse_smt_ans_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <a href="../../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></code></dt><dd><p>Parse a single Isla expression from a channel</p></dd></dl><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../AstGen/index.html#module-Parser_pp">AstGen.Parser_pp</a></code></span></summary><dl><dt class="spec value" id="val-pp_raw_bvar"><a href="#val-pp_raw_bvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvf"><a href="#val-pp_raw_bvf" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvf : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_flag"><a href="#val-pp_raw_flag" class="anchor"></a><code><span class="keyword">val</span> pp_raw_flag : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span class="keyword">val</span> pp_raw_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum : <a href="../../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span class="keyword">val</span> pp_raw_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span class="keyword">val</span> pp_raw_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_mem_size"><a href="#val-pp_raw_mem_size" class="anchor"></a><code><span class="keyword">val</span> pp_raw_mem_size : <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_raw_binmem"><a href="#val-pp_raw_binmem" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binmem : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_var"><a href="#val-pp_raw_var" class="anchor"></a><code><span class="keyword">val</span> pp_raw_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bbvar"><a href="#val-pp_raw_bbvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bbvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bind"><a href="#val-pp_raw_bind" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bind : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_fbool"><a href="#val-pp_raw_fbool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_fbool : <span>(string * bool)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smts"><a href="#val-pp_raw_smts" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smts : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt_ans"><a href="#val-pp_raw_smt_ans" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt_ans : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_ty : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_unop : <a href="../../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvarith : <a href="../../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvcomp : <a href="../../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binop : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvmanyarith : <a href="../../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_manyop : <a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvar"><a href="#val-pp_bvar" class="anchor"></a><code><span class="keyword">val</span> pp_bvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvf"><a href="#val-pp_bvf" class="anchor"></a><code><span class="keyword">val</span> pp_bvf : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_flag"><a href="#val-pp_flag" class="anchor"></a><code><span class="keyword">val</span> pp_flag : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span class="keyword">val</span> pp_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span class="keyword">val</span> pp_enum : <a href="../../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span class="keyword">val</span> pp_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span class="keyword">val</span> pp_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span class="keyword">val</span> pp_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span class="keyword">val</span> pp_j : int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_mem_size"><a href="#val-pp_mem_size" class="anchor"></a><code><span class="keyword">val</span> pp_mem_size : <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_binmem"><a href="#val-pp_binmem" class="anchor"></a><code><span class="keyword">val</span> pp_binmem : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_var"><a href="#val-pp_var" class="anchor"></a><code><span class="keyword">val</span> pp_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bbvar"><a href="#val-pp_bbvar" class="anchor"></a><code><span class="keyword">val</span> pp_bbvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bind"><a href="#val-pp_bind" class="anchor"></a><code><span class="keyword">val</span> pp_bind : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_fbool"><a href="#val-pp_fbool" class="anchor"></a><code><span class="keyword">val</span> pp_fbool : <span>(string * bool)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smts"><a href="#val-pp_smts" class="anchor"></a><code><span class="keyword">val</span> pp_smts : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt_ans"><a href="#val-pp_smt_ans" class="anchor"></a><code><span class="keyword">val</span> pp_smt_ans : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span class="keyword">val</span> pp_ty : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span class="keyword">val</span> pp_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span class="keyword">val</span> pp_unop : <a href="../../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvarith : <a href="../../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_bvcomp : <a href="../../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span class="keyword">val</span> pp_binop : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvmanyarith : <a href="../../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_manyop : <a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-pp_loc"><a href="#val-pp_loc" class="anchor"></a><code><span class="keyword">val</span> pp_loc : Stdlib.Lexing.position <span>&#45;&gt;</span> PPrint.document</code></dt><dd><p>Prints a lexing location</p></dd></dl><dl><dt class="spec value" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span class="keyword">val</span> pp_lrng : Isla_lang.AST.lrng <span>&#45;&gt;</span> PPrint.document</code></dt><dd><p>Prints a lexing range</p></dd></dl></section><section><header><h2 id="analysers"><a href="#analysers" class="anchor"></a>Analysers</h2><p>All function that start with <code>is_</code></p></header><dl><dt class="spec value" id="val-is_atomic"><a href="#val-is_atomic" class="anchor"></a><code><span class="keyword">val</span> is_atomic : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> bool</code></dt></dl></section><section><header><h2 id="destr"><a href="#destr" class="anchor"></a>Destructors</h2><p>Aparently I overestimated ocaml type-system in it's handling of empty types.</p><p>Here are some function to destroy empty types.</p></header><dl><dt class="spec value" id="val-destr_binmem"><a href="#val-destr_binmem" class="anchor"></a><code><span class="keyword">val</span> destr_binmem : <span><a href="index.html#type-no">no</a> <a href="index.html#type-binmem">binmem</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl></section><section><header><h2 id="expectors"><a href="#expectors" class="anchor"></a>Expectors</h2><p>Functions to assert that a specific constructor is used and get the value</p></header><dl><dt class="spec value" id="val-expect_bits"><a href="#val-expect_bits" class="anchor"></a><code><span class="keyword">val</span> expect_bits : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></code></dt><dt class="spec value" id="val-ty_expect_bv"><a href="#val-ty_expect_bv" class="anchor"></a><code><span class="keyword">val</span> ty_expect_bv : <span><span class="type-var">'a</span> <a href="index.html#type-ty">ty</a></span> <span>&#45;&gt;</span> int</code></dt></dl></section><section><header><h2 id="construtors"><a href="#construtors" class="anchor"></a>Construtors</h2></header><dl><dt class="spec value" id="val-assert_smt"><a href="#val-assert_smt" class="anchor"></a><code><span class="keyword">val</span> assert_smt : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-smt">smt</a></span></code></dt><dt class="spec value" id="val-simplify_smt"><a href="#val-simplify_smt" class="anchor"></a><code><span class="keyword">val</span> simplify_smt : <span>?&#8288;flags:<span><span>(string * bool)</span> list</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-smt">smt</a></span></code></dt></dl></section><section><header><h2 id="comparisons"><a href="#comparisons" class="anchor"></a>Comparisons</h2></header><dl><dt class="spec value" id="val-equal_exp"><a href="#val-equal_exp" class="anchor"></a><code><span class="keyword">val</span> equal_exp : <span>?&#8288;annot:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>var:<span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>?&#8288;bnd:<span>(<span class="type-var">'c</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality for expressions; default polymorphic equality will fail.</p></dd></dl></section></div></body></html>
\ No newline at end of file
+let f : complex_empty = function A _ | B _ -&gt; . (* compiles *)</code></pre><p>In case this behavior is needed, there <a href="../index.html#destr" title="destr">Destructors</a> in <a href="../index.html"><code>Ast</code></a>. See this section to see how they are used.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span><span class="keyword">type</span> loc</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></div><div class="spec-doc"><p><a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Lexing.html#TYPEposition"><code>Lexing.position</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span><span class="keyword">type</span> lrng</span><span> = <span class="xref-unresolved">Isla_lang</span>.AST.lrng</span></code></div><div class="spec-doc"><p>The type of an expression range. This imported from Isla to avoid having two incompatible types.</p><p>This represent a range in a source file, so generally this is a pair of <a href="#val-loc"><code>loc</code></a>, but it may also be <code>Unknown</code>.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span><span class="keyword">type</span> rexp</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="#type-exp">exp</a></span></span></code></div><div class="spec-doc"><p>Raw expression coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rty"><a href="#type-rty" class="anchor"></a><code><span><span class="keyword">type</span> rty</span><span> = <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="#type-ty">ty</a></span></span></code></div><div class="spec-doc"><p>Raw type coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span><span class="keyword">type</span> rsmt</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="#type-smt">smt</a></span></span></code></div><div class="spec-doc"><p>Raw SMT command coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt_ans"><a href="#type-rsmt_ans" class="anchor"></a><code><span><span class="keyword">type</span> rsmt_ans</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="#type-smt_ans">smt_ans</a></span></span></code></div><div class="spec-doc"><p>Raw SMT answer coming out of the parser</p></div></div></details></div><h2 id="size"><a href="#size" class="anchor"></a>Size</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Size/index.html">Size</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><h2 id="parsing"><a href="#parsing" class="anchor"></a>Parsing</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span><span class="keyword">module</span> Parser</span><span> = <a href="../../AstGen/Parser/index.html">AstGen.Parser</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span><span class="keyword">module</span> Lexer</span><span> = <a href="../../AstGen/Lexer/index.html">AstGen.Lexer</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unknown"><a href="#val-unknown" class="anchor"></a><code><span><span class="keyword">val</span> unknown : <span class="xref-unresolved">Isla_lang</span>.AST.lrng</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-loc"><a href="#val-loc" class="anchor"></a><code><span><span class="keyword">val</span> loc : <span><span class="xref-unresolved">Stdlib</span>.Lexing.position <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla parsing error</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">LexError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla lexing error</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lexbuf"><a href="#type-lexbuf" class="anchor"></a><code><span><span class="keyword">type</span> lexbuf</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span><span class="keyword">type</span> lexer</span><span> = <span><a href="#type-lexbuf">lexbuf</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../AstGen/Parser/index.html#type-token">Parser.token</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a parser</span></span><span> = <span><a href="#type-lexer">lexer</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-lexbuf">lexbuf</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span><span class="keyword">val</span> parse : <span><span><span class="type-var">'a</span> <a href="#type-parser">parser</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-lexbuf">lexbuf</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from_string"><a href="#val-from_string" class="anchor"></a><code><span><span class="keyword">val</span> from_string : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from_channel"><a href="#val-from_channel" class="anchor"></a><code><span><span class="keyword">val</span> from_channel : <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_string : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_channel : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_smt_ans_string"><a href="#val-parse_smt_ans_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_smt_ans_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="../../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_smt_ans_channel"><a href="#val-parse_smt_ans_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_smt_ans_channel : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a channel</p></div></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../AstGen/Parser_pp/index.html">AstGen.Parser_pp</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvar"><a href="#val-pp_raw_bvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvf"><a href="#val-pp_raw_bvf" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvf : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_flag"><a href="#val-pp_raw_flag" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_flag : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum : <span><a href="../../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_nat"><a href="#val-pp_raw_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_mem_size"><a href="#val-pp_raw_mem_size" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_mem_size : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binmem"><a href="#val-pp_raw_binmem" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binmem : <span><span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_var"><a href="#val-pp_raw_var" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_var : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bbvar"><a href="#val-pp_raw_bbvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bbvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bind"><a href="#val-pp_raw_bind" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bind : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_fbool"><a href="#val-pp_raw_fbool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_fbool : <span><span>(string * bool)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smts"><a href="#val-pp_raw_smts" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smts : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt_ans"><a href="#val-pp_raw_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt_ans : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_ty : <span><span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_unop : <span><a href="../../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvarith : <span><a href="../../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvcomp : <span><a href="../../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binop : <span><span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvmanyarith : <span><a href="../../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_manyop : <span><a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvar"><a href="#val-pp_bvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvf"><a href="#val-pp_bvf" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvf : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_flag"><a href="#val-pp_flag" class="anchor"></a><code><span><span class="keyword">val</span> pp_flag : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum : <span><a href="../../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_nat"><a href="#val-pp_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span><span class="keyword">val</span> pp_j : <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_mem_size"><a href="#val-pp_mem_size" class="anchor"></a><code><span><span class="keyword">val</span> pp_mem_size : <span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binmem"><a href="#val-pp_binmem" class="anchor"></a><code><span><span class="keyword">val</span> pp_binmem : <span><span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_var"><a href="#val-pp_var" class="anchor"></a><code><span><span class="keyword">val</span> pp_var : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bbvar"><a href="#val-pp_bbvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bbvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bind"><a href="#val-pp_bind" class="anchor"></a><code><span><span class="keyword">val</span> pp_bind : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_fbool"><a href="#val-pp_fbool" class="anchor"></a><code><span><span class="keyword">val</span> pp_fbool : <span><span>(string * bool)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smts"><a href="#val-pp_smts" class="anchor"></a><code><span><span class="keyword">val</span> pp_smts : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt_ans"><a href="#val-pp_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt_ans : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_ty : <span><span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_unop : <span><a href="../../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvarith : <span><a href="../../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvcomp : <span><a href="../../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_binop : <span><span><a href="../../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvmanyarith : <span><a href="../../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_manyop : <span><a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_loc"><a href="#val-pp_loc" class="anchor"></a><code><span><span class="keyword">val</span> pp_loc : <span><span class="xref-unresolved">Stdlib</span>.Lexing.position <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Prints a lexing location</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span><span class="keyword">val</span> pp_lrng : <span><span class="xref-unresolved">Isla_lang</span>.AST.lrng <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Prints a lexing range</p></div></div><h2 id="analysers"><a href="#analysers" class="anchor"></a>Analysers</h2><p>All function that start with <code>is_</code></p><div class="odoc-spec"><div class="spec value anchored" id="val-is_atomic"><a href="#val-is_atomic" class="anchor"></a><code><span><span class="keyword">val</span> is_atomic : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><h2 id="destr"><a href="#destr" class="anchor"></a>Destructors</h2><p>Aparently I overestimated ocaml type-system in it's handling of empty types.</p><p>Here are some function to destroy empty types.</p><div class="odoc-spec"><div class="spec value anchored" id="val-destr_binmem"><a href="#val-destr_binmem" class="anchor"></a><code><span><span class="keyword">val</span> destr_binmem : <span><span><a href="#type-no">no</a> <a href="#type-binmem">binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><h2 id="expectors"><a href="#expectors" class="anchor"></a>Expectors</h2><p>Functions to assert that a specific constructor is used and get the value</p><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bits"><a href="#val-expect_bits" class="anchor"></a><code><span><span class="keyword">val</span> expect_bits : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty_expect_bv"><a href="#val-ty_expect_bv" class="anchor"></a><code><span><span class="keyword">val</span> ty_expect_bv : <span><span><span class="type-var">'a</span> <a href="#type-ty">ty</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><h2 id="construtors"><a href="#construtors" class="anchor"></a>Construtors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-assert_smt"><a href="#val-assert_smt" class="anchor"></a><code><span><span class="keyword">val</span> assert_smt : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-smt">smt</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_smt"><a href="#val-simplify_smt" class="anchor"></a><code><span><span class="keyword">val</span> simplify_smt : 
+  <span><span class="optlabel">?flags</span>:<span><span>(string * bool)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-smt">smt</a></span></span></code></div></div><h2 id="comparisons"><a href="#comparisons" class="anchor"></a>Comparisons</h2><div class="odoc-spec"><div class="spec value anchored" id="val-equal_exp"><a href="#val-equal_exp" class="anchor"></a><code><span><span class="keyword">val</span> equal_exp : 
+  <span><span class="optlabel">?annot</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">var</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?bnd</span>:<span>(<span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  bool</span></code></div><div class="spec-doc"><p>Equality for expressions; default polymorphic equality will fail.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Ast/Manip/index.html b/doc/html/read-dwarf/Ast/Manip/index.html
index c3d353bf..66f484a8 100644
--- a/doc/html/read-dwarf/Ast/Manip/index.html
+++ b/doc/html/read-dwarf/Ast/Manip/index.html
@@ -1,2 +1,35 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Manip (read-dwarf.Ast.Manip)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Ast</a> &#x00BB; Manip</nav><h1>Module <code>Ast.Manip</code></h1><p>This module provide generic facilities of expression and SMT statements provided by <a href="../index.html"><code>Ast</code></a>. It is intended to only provide syntactic facilities over <a href="../index.html"><code>Ast</code></a> types, in particular <a href="../index.html#type-exp"><code>Ast.exp</code></a>.</p><p>In particular it provides generic mapping and iteration function over expressions as well a function allowing to convert between the various <a href="../../SymbolicExpressions.html#typopt"><span>Expression type parameter and options</span></a>.</p><p>Warning: due to OCaml type system limitations, mainly <a href="https://github.com/ocaml/ocaml/issues/9459">issue <code>#9456</code></a>, this module is sometimes required to use <span class="xref-unresolved" title="unresolved reference to &quot;Obj.magic&quot;"><code>Obj</code>.magic</span> in some specific cases. No other module should ever do that. If you need to use <code>Obj.magic</code> to bypass OCaml type system limitation about <a href="../index.html"><code>Ast</code></a> type, add a function here instead.</p><nav class="toc"><ul><li><a href="#get-annotations">Get annotations</a></li><li><a href="#non-recursive-maps-and-iters">Non-recursive maps and iters</a></li><li><a href="#recursive-maps-and-iters">Recursive maps and iters</a></li><li><a href="#variable-type-conversion">Variable type conversion</a></li><li><a href="#bound-variables-and-let-bindings">Bound variables and let-bindings</a></li><li><a href="#memory-operation">Memory operation</a></li></ul></nav></header><section><header><h2 id="get-annotations"><a href="#get-annotations" class="anchor"></a>Get annotations</h2></header><dl><dt class="spec value" id="val-annot_exp"><a href="#val-annot_exp" class="anchor"></a><code><span class="keyword">val</span> annot_exp : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the annotation of an expression</p><p>TODO: This would be much more efficient if the annotation was always the first member of the constructor and not the last (in that case the offset to fetch the annotation do not depend on the constructor index). This may require to modify ott.</p></dd></dl></section><section><header><h2 id="non-recursive-maps-and-iters"><a href="#non-recursive-maps-and-iters" class="anchor"></a>Non-recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>direct_a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively. Then a new a with the same structure is formed.</p><p><code>direct_a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively.</p></header><dl><dt class="spec value" id="val-direct_exp_map_exp"><a href="#val-direct_exp_map_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_map_exp : <span>(<span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dt class="spec value" id="val-direct_exp_iter_exp"><a href="#val-direct_exp_iter_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_iter_exp : <span>(<span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-direct_exp_fold_left_exp"><a href="#val-direct_exp_fold_left_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_fold_left_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-direct_exp_for_all_exp"><a href="#val-direct_exp_for_all_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_for_all_exp : <span>(<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-direct_exp_exists_exp"><a href="#val-direct_exp_exists_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_exists_exp : <span>(<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> bool</code></dt></dl></section><section><header><h2 id="recursive-maps-and-iters"><a href="#recursive-maps-and-iters" class="anchor"></a>Recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively on all b that appear directly or indirectly in a</p><p><code>a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively</p><p>Doing this when <code>a = b</code> is not well defined, and can be easily done using the direct version from previous section.</p></header><dl><dt class="spec value" id="val-exp_iter_var"><a href="#val-exp_iter_var" class="anchor"></a><code><span class="keyword">val</span> exp_iter_var : <span>(<span class="type-var">'v</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterate a function on all the variable of an expression</p></dd></dl><dl><dt class="spec value" id="val-exp_map_var"><a href="#val-exp_map_var" class="anchor"></a><code><span class="keyword">val</span> exp_map_var : va vb a b m. <span>(<span class="type-var">'va</span> <span>&#45;&gt;</span> <span class="type-var">'vb</span>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'va</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'vb</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dt class="spec value" id="val-exp_iter_annot"><a href="#val-exp_iter_annot" class="anchor"></a><code><span class="keyword">val</span> exp_iter_annot : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterate a function on all the annotations of an expression</p></dd></dl></section><section><header><h2 id="variable-type-conversion"><a href="#variable-type-conversion" class="anchor"></a>Variable type conversion</h2><p>All of those function convert the underlying variable type through the AST. They cannot be the usual map function because they change the type</p></header><dl><dt class="spec value" id="val-exp_conv_var"><a href="#val-exp_conv_var" class="anchor"></a><code><span class="keyword">val</span> exp_conv_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'c</span>, <span class="type-var">'a</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'c</span>, <span class="type-var">'b</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dd><p>Old alias to make conversion explicit</p></dd></dl><dl><dt class="spec value" id="val-exp_var_subst"><a href="#val-exp_var_subst" class="anchor"></a><code><span class="keyword">val</span> exp_var_subst : va a vb b m. <span>(<span class="type-var">'va</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'vb</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'va</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'vb</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dd><p>Substitute variable with expression according to substitution function</p></dd></dl></section><section><header><h2 id="bound-variables-and-let-bindings"><a href="#bound-variables-and-let-bindings" class="anchor"></a>Bound variables and let-bindings</h2><p>This section allow to go from expression without let-bindings to expression with them and vice-versa.</p></header><dl><dt class="spec value" id="val-allow_lets"><a href="#val-allow_lets" class="anchor"></a><code><span class="keyword">val</span> allow_lets : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../Base/index.html#type-no">Base.no</a>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dd><p>Allow bound variables and lets in an expression. This operation is a no-op and has no runtime cost, it's just a type change.</p></dd></dl><dl><dt class="spec value" id="val-smt_allow_lets"><a href="#val-smt_allow_lets" class="anchor"></a><code><span class="keyword">val</span> smt_allow_lets : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../Base/index.html#type-no">Base.no</a>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span></code></dt><dd><p>Same as <a href="index.html#val-allow_lets"><code>allow_lets</code></a> but for the <a href="../index.html#type-smt"><code>smt</code></a> type</p></dd></dl><dl><dt class="spec value" id="val-unfold_lets"><a href="#val-unfold_lets" class="anchor"></a><code><span class="keyword">val</span> unfold_lets : b1 a v b2 m. <span>?&#8288;context:<span><span>(<span class="type-var">'b1</span>, <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b2</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> Stdlib.Hashtbl.t</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b1</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b2</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dd><p>Unfold all lets. There are no remaining lets in the output, Therefore the output type of let binding can be anything including <a href="../index.html#type-no"><code>Ast.no</code></a>. In particular doing <a href="index.html#val-allow_lets"><code>allow_lets</code></a> after this function is useless</p></dd></dl></section><section><header><h2 id="memory-operation"><a href="#memory-operation" class="anchor"></a>Memory operation</h2><p>This section allow to go from expression without memory operations to expression with them and vice-versa.</p></header><dl><dt class="spec value" id="val-allow_mem"><a href="#val-allow_mem" class="anchor"></a><code><span class="keyword">val</span> allow_mem : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <a href="../Base/index.html#type-no">Base.no</a>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dd><p>Allow memory operations in an expression.</p></dd></dl><dl><dt class="spec value" id="val-smt_allow_mem"><a href="#val-smt_allow_mem" class="anchor"></a><code><span class="keyword">val</span> smt_allow_mem : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <a href="../Base/index.html#type-no">Base.no</a>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span></code></dt><dd><p>Same as <a href="index.html#val-allow_mem"><code>allow_mem</code></a> but for the <a href="../index.html#type-smt"><code>smt</code></a> type</p></dd></dl><dl><dt class="spec value" id="val-ty_allow_mem"><a href="#val-ty_allow_mem" class="anchor"></a><code><span class="keyword">val</span> ty_allow_mem : <span><a href="../Base/index.html#type-no">Base.no</a> <a href="../Base/index.html#type-ty">Base.ty</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'m</span> <a href="../Base/index.html#type-ty">Base.ty</a></span></code></dt><dd><p>Same as <a href="index.html#val-allow_mem"><code>allow_mem</code></a> but for the <a href="../index.html#type-ty"><code>ty</code></a> type</p></dd></dl><dl><dt class="spec value" id="val-check_no_mem"><a href="#val-check_no_mem" class="anchor"></a><code><span class="keyword">val</span> check_no_mem : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check that not memory operation take place in that expression. Return <code>true</code> if that's the case and <code>false</code> otherwise.</p><p>This is not resilient to change of type: If a new memory constructor is added, then this function will be wrong</p></dd></dl><dl><dt class="spec value" id="val-expect_no_mem"><a href="#val-expect_no_mem" class="anchor"></a><code><span class="keyword">val</span> expect_no_mem : <span>?&#8288;handler:<span>(unit <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m2</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m1</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m2</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></code></dt><dd><p>Expect that an <code>exp</code> has no memory constructor, and then return it with memory removed from the type. Throws <code>Failure</code> if the value had memory constructors.</p><p>This is not resilient to change of type, If a new memory constructor is added, then this function will be unsound.</p><p>TODO: Find a way to make it resilient</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Manip (read-dwarf.Ast.Manip)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Ast</a> &#x00BB; Manip</nav><header class="odoc-preamble"><h1>Module <code><span>Ast.Manip</span></code></h1><p>This module provide generic facilities of expression and SMT statements provided by <a href="../index.html"><code>Ast</code></a>. It is intended to only provide syntactic facilities over <a href="../index.html"><code>Ast</code></a> types, in particular <a href="../index.html#type-exp"><code>Ast.exp</code></a>.</p><p>In particular it provides generic mapping and iteration function over expressions as well a function allowing to convert between the various <a href="../../SymbolicExpressions.html#typopt" title="typopt">Expression type parameter and options</a>.</p><p>Warning: due to OCaml type system limitations, mainly <a href="https://github.com/ocaml/ocaml/issues/9459">issue <code>#9456</code></a>, this module is sometimes required to use <code>Obj.magic</code> in some specific cases. No other module should ever do that. If you need to use <code>Obj.magic</code> to bypass OCaml type system limitation about <a href="../index.html"><code>Ast</code></a> type, add a function here instead.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#get-annotations">Get annotations</a></li><li><a href="#non-recursive-maps-and-iters">Non-recursive maps and iters</a></li><li><a href="#recursive-maps-and-iters">Recursive maps and iters</a></li><li><a href="#variable-type-conversion">Variable type conversion</a></li><li><a href="#bound-variables-and-let-bindings">Bound variables and let-bindings</a></li><li><a href="#memory-operation">Memory operation</a></li></ul></nav></div><div class="odoc-content"><h2 id="get-annotations"><a href="#get-annotations" class="anchor"></a>Get annotations</h2><div class="odoc-spec"><div class="spec value anchored" id="val-annot_exp"><a href="#val-annot_exp" class="anchor"></a><code><span><span class="keyword">val</span> annot_exp : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the annotation of an expression</p><p>TODO: This would be much more efficient if the annotation was always the first member of the constructor and not the last (in that case the offset to fetch the annotation do not depend on the constructor index). This may require to modify ott.</p></div></div><h2 id="non-recursive-maps-and-iters"><a href="#non-recursive-maps-and-iters" class="anchor"></a>Non-recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>direct_a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively. Then a new a with the same structure is formed.</p><p><code>direct_a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively.</p><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_map_exp"><a href="#val-direct_exp_map_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_map_exp : 
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_iter_exp"><a href="#val-direct_exp_iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_iter_exp : 
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_fold_left_exp"><a href="#val-direct_exp_fold_left_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_fold_left_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_for_all_exp"><a href="#val-direct_exp_for_all_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_for_all_exp : 
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_exists_exp"><a href="#val-direct_exp_exists_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_exists_exp : 
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  bool</span></code></div></div><h2 id="recursive-maps-and-iters"><a href="#recursive-maps-and-iters" class="anchor"></a>Recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively on all b that appear directly or indirectly in a</p><p><code>a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively</p><p>Doing this when <code>a = b</code> is not well defined, and can be easily done using the direct version from previous section.</p><div class="odoc-spec"><div class="spec value anchored" id="val-exp_iter_var"><a href="#val-exp_iter_var" class="anchor"></a><code><span><span class="keyword">val</span> exp_iter_var : <span><span>(<span><span class="type-var">'v</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterate a function on all the variable of an expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_map_var"><a href="#val-exp_map_var" class="anchor"></a><code><span><span class="keyword">val</span> exp_map_var : 
+  'va 'vb 'a 'b 'm. <span><span>(<span><span class="type-var">'va</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'vb</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'va</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'vb</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_iter_annot"><a href="#val-exp_iter_annot" class="anchor"></a><code><span><span class="keyword">val</span> exp_iter_annot : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterate a function on all the annotations of an expression</p></div></div><h2 id="variable-type-conversion"><a href="#variable-type-conversion" class="anchor"></a>Variable type conversion</h2><p>All of those function convert the underlying variable type through the AST. They cannot be the usual map function because they change the type</p><div class="odoc-spec"><div class="spec value anchored" id="val-exp_conv_var"><a href="#val-exp_conv_var" class="anchor"></a><code><span><span class="keyword">val</span> exp_conv_var : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'c</span>, <span class="type-var">'a</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'c</span>, <span class="type-var">'b</span>, <span class="type-var">'d</span>, <span class="type-var">'e</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Old alias to make conversion explicit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_var_subst"><a href="#val-exp_var_subst" class="anchor"></a><code><span><span class="keyword">val</span> exp_var_subst : 
+  'va 'a 'vb 'b 'm. <span><span>(<span><span class="type-var">'va</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'vb</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'va</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'vb</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Substitute variable with expression according to substitution function</p></div></div><h2 id="bound-variables-and-let-bindings"><a href="#bound-variables-and-let-bindings" class="anchor"></a>Bound variables and let-bindings</h2><p>This section allow to go from expression without let-bindings to expression with them and vice-versa.</p><div class="odoc-spec"><div class="spec value anchored" id="val-allow_lets"><a href="#val-allow_lets" class="anchor"></a><code><span><span class="keyword">val</span> allow_lets : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../Base/index.html#type-no">Base.no</a>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Allow bound variables and lets in an expression. This operation is a no-op and has no runtime cost, it's just a type change.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smt_allow_lets"><a href="#val-smt_allow_lets" class="anchor"></a><code><span><span class="keyword">val</span> smt_allow_lets : 
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../Base/index.html#type-no">Base.no</a>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-allow_lets"><code>allow_lets</code></a> but for the <a href="../index.html#type-smt"><code>smt</code></a> type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unfold_lets"><a href="#val-unfold_lets" class="anchor"></a><code><span><span class="keyword">val</span> unfold_lets : 
+  'b1 'a 'v 'b2 'm. <span><span class="optlabel">?context</span>:<span><span>(<span class="type-var">'b1</span>, <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b2</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b1</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b2</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Unfold all lets. There are no remaining lets in the output, Therefore the output type of let binding can be anything including <a href="../index.html#type-no"><code>Ast.no</code></a>. In particular doing <a href="#val-allow_lets"><code>allow_lets</code></a> after this function is useless</p></div></div><h2 id="memory-operation"><a href="#memory-operation" class="anchor"></a>Memory operation</h2><p>This section allow to go from expression without memory operations to expression with them and vice-versa.</p><div class="odoc-spec"><div class="spec value anchored" id="val-allow_mem"><a href="#val-allow_mem" class="anchor"></a><code><span><span class="keyword">val</span> allow_mem : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <a href="../Base/index.html#type-no">Base.no</a>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Allow memory operations in an expression.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smt_allow_mem"><a href="#val-smt_allow_mem" class="anchor"></a><code><span><span class="keyword">val</span> smt_allow_mem : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <a href="../Base/index.html#type-no">Base.no</a>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-smt">Base.smt</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-allow_mem"><code>allow_mem</code></a> but for the <a href="../index.html#type-smt"><code>smt</code></a> type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty_allow_mem"><a href="#val-ty_allow_mem" class="anchor"></a><code><span><span class="keyword">val</span> ty_allow_mem : <span><span><a href="../Base/index.html#type-no">Base.no</a> <a href="../Base/index.html#type-ty">Base.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'m</span> <a href="../Base/index.html#type-ty">Base.ty</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-allow_mem"><code>allow_mem</code></a> but for the <a href="../index.html#type-ty"><code>ty</code></a> type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_no_mem"><a href="#val-check_no_mem" class="anchor"></a><code><span><span class="keyword">val</span> check_no_mem : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check that not memory operation take place in that expression. Return <code>true</code> if that's the case and <code>false</code> otherwise.</p><p>This is not resilient to change of type: If a new memory constructor is added, then this function will be wrong</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_no_mem"><a href="#val-expect_no_mem" class="anchor"></a><code><span><span class="keyword">val</span> expect_no_mem : 
+  <span><span class="optlabel">?handler</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m2</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m1</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m2</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Expect that an <code>exp</code> has no memory constructor, and then return it with memory removed from the type. Throws <code>Failure</code> if the value had memory constructors.</p><p>This is not resilient to change of type, If a new memory constructor is added, then this function will be unsound.</p><p>TODO: Find a way to make it resilient</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-all_subterms"><a href="#val-all_subterms" class="anchor"></a><code><span><span class="keyword">val</span> all_subterms : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> list</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Ast/index.html b/doc/html/read-dwarf/Ast/index.html
index d404b5a8..515ae0e9 100644
--- a/doc/html/read-dwarf/Ast/index.html
+++ b/doc/html/read-dwarf/Ast/index.html
@@ -1,7 +1,58 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Ast (read-dwarf.Ast)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Ast</nav><h1>Module <code>Ast</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="index.html#module-Base">Base</a></code></span></summary><aside><p>The main module to use the AST of expression and SMT operation for a more generic overview of the AST, see <a href="../SymbolicExpressions.html"><code>SymbolicExpressions</code></a>.</p></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../AstGen/index.html#module-Def">AstGen.Def</a></code></span></summary><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../AstGen/index.html#module-Ott">AstGen.Ott</a></code></span></summary><aside><p>warning: the backend selected ignores the file structure informations</p></aside><dl><dt class="spec type" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span class="keyword">type</span> bvar</code><code> = string</code></dt><dd><p>syntax</p></dd></dl><dl><dt class="spec type" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span class="keyword">type</span> flag</code><code> = string</code></dt><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = int * int</code></dt><dt class="spec type" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span class="keyword">type</span> <span>'m binmem</span></code><code> = </code><table class="variant"><tr id="type-binmem.Select" class="anchored"><td class="def constructor"><a href="#type-binmem.Select" class="anchor"></a><code>| </code><code><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-binmem.Store" class="anchored"><td class="def constructor"><a href="#type-binmem.Store" class="anchor"></a><code>| </code><code><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr></table></dt><dt class="spec type" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span class="keyword">type</span> bvarith</code><code> = </code><table class="variant"><tr id="type-bvarith.Bvuremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvuremi</span></code></td></tr><tr id="type-bvarith.Bvsremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsremi</span></code></td></tr><tr id="type-bvarith.Bvsmodi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmodi</span></code></td></tr><tr id="type-bvarith.Bvnand" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnand" class="anchor"></a><code>| </code><code><span class="constructor">Bvnand</span></code></td></tr><tr id="type-bvarith.Bvnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvnor</span></code></td></tr><tr id="type-bvarith.Bvxnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxnor</span></code></td></tr><tr id="type-bvarith.Bvsub" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsub" class="anchor"></a><code>| </code><code><span class="constructor">Bvsub</span></code></td></tr><tr id="type-bvarith.Bvudiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvudiv</span></code></td></tr><tr id="type-bvarith.Bvudivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvudivi</span></code></td></tr><tr id="type-bvarith.Bvsdiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdiv</span></code></td></tr><tr id="type-bvarith.Bvsdivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdivi</span></code></td></tr><tr id="type-bvarith.Bvurem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvurem" class="anchor"></a><code>| </code><code><span class="constructor">Bvurem</span></code></td></tr><tr id="type-bvarith.Bvsrem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code>| </code><code><span class="constructor">Bvsrem</span></code></td></tr><tr id="type-bvarith.Bvsmod" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmod</span></code></td></tr><tr id="type-bvarith.Bvshl" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvshl" class="anchor"></a><code>| </code><code><span class="constructor">Bvshl</span></code></td></tr><tr id="type-bvarith.Bvlshr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code>| </code><code><span class="constructor">Bvlshr</span></code></td></tr><tr id="type-bvarith.Bvashr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvashr" class="anchor"></a><code>| </code><code><span class="constructor">Bvashr</span></code></td></tr></table></dt><dt class="spec type" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span class="keyword">type</span> bvcomp</code><code> = </code><table class="variant"><tr id="type-bvcomp.Bvult" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvult" class="anchor"></a><code>| </code><code><span class="constructor">Bvult</span></code></td></tr><tr id="type-bvcomp.Bvslt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code>| </code><code><span class="constructor">Bvslt</span></code></td></tr><tr id="type-bvcomp.Bvule" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvule" class="anchor"></a><code>| </code><code><span class="constructor">Bvule</span></code></td></tr><tr id="type-bvcomp.Bvsle" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code>| </code><code><span class="constructor">Bvsle</span></code></td></tr><tr id="type-bvcomp.Bvuge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code>| </code><code><span class="constructor">Bvuge</span></code></td></tr><tr id="type-bvcomp.Bvsge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code>| </code><code><span class="constructor">Bvsge</span></code></td></tr><tr id="type-bvcomp.Bvugt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code>| </code><code><span class="constructor">Bvugt</span></code></td></tr><tr id="type-bvcomp.Bvsgt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code>| </code><code><span class="constructor">Bvsgt</span></code></td></tr></table></dt><dt class="spec type" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span class="keyword">type</span> bvmanyarith</code><code> = </code><table class="variant"><tr id="type-bvmanyarith.Bvand" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code>| </code><code><span class="constructor">Bvand</span></code></td></tr><tr id="type-bvmanyarith.Bvor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code>| </code><code><span class="constructor">Bvor</span></code></td></tr><tr id="type-bvmanyarith.Bvxor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxor</span></code></td></tr><tr id="type-bvmanyarith.Bvadd" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code>| </code><code><span class="constructor">Bvadd</span></code></td></tr><tr id="type-bvmanyarith.Bvmul" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code>| </code><code><span class="constructor">Bvmul</span></code></td></tr></table></dt><dt class="spec type" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span class="keyword">type</span> unop</code><code> = </code><table class="variant"><tr id="type-unop.Not" class="anchored"><td class="def constructor"><a href="#type-unop.Not" class="anchor"></a><code>| </code><code><span class="constructor">Not</span></code></td></tr><tr id="type-unop.Bvnot" class="anchored"><td class="def constructor"><a href="#type-unop.Bvnot" class="anchor"></a><code>| </code><code><span class="constructor">Bvnot</span></code></td></tr><tr id="type-unop.Bvredand" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredand" class="anchor"></a><code>| </code><code><span class="constructor">Bvredand</span></code></td></tr><tr id="type-unop.Bvredor" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredor" class="anchor"></a><code>| </code><code><span class="constructor">Bvredor</span></code></td></tr><tr id="type-unop.Bvneg" class="anchored"><td class="def constructor"><a href="#type-unop.Bvneg" class="anchor"></a><code>| </code><code><span class="constructor">Bvneg</span></code></td></tr><tr id="type-unop.Extract" class="anchored"><td class="def constructor"><a href="#type-unop.Extract" class="anchor"></a><code>| </code><code><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-unop.ZeroExtend" class="anchored"><td class="def constructor"><a href="#type-unop.ZeroExtend" class="anchor"></a><code>| </code><code><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-unop.SignExtend" class="anchored"><td class="def constructor"><a href="#type-unop.SignExtend" class="anchor"></a><code>| </code><code><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span class="keyword">type</span> <span>'m binop</span></code><code> = </code><table class="variant"><tr id="type-binop.Binmem" class="anchored"><td class="def constructor"><a href="#type-binop.Binmem" class="anchor"></a><code>| </code><code><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binmem">binmem</a></span></code></td></tr><tr id="type-binop.Eq" class="anchored"><td class="def constructor"><a href="#type-binop.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span></code></td></tr><tr id="type-binop.Bvarith" class="anchored"><td class="def constructor"><a href="#type-binop.Bvarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="index.html#type-bvarith">bvarith</a></code></td></tr><tr id="type-binop.Bvcomp" class="anchored"><td class="def constructor"><a href="#type-binop.Bvcomp" class="anchor"></a><code>| </code><code><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="index.html#type-bvcomp">bvcomp</a></code></td></tr></table></dt><dt class="spec type" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span class="keyword">type</span> manyop</code><code> = </code><table class="variant"><tr id="type-manyop.And" class="anchored"><td class="def constructor"><a href="#type-manyop.And" class="anchor"></a><code>| </code><code><span class="constructor">And</span></code></td></tr><tr id="type-manyop.Or" class="anchored"><td class="def constructor"><a href="#type-manyop.Or" class="anchor"></a><code>| </code><code><span class="constructor">Or</span></code></td></tr><tr id="type-manyop.Bvmanyarith" class="anchored"><td class="def constructor"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="index.html#type-bvmanyarith">bvmanyarith</a></code></td></tr><tr id="type-manyop.Concat" class="anchored"><td class="def constructor"><a href="#type-manyop.Concat" class="anchor"></a><code>| </code><code><span class="constructor">Concat</span></code></td></tr></table></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></code><code> = </code><table class="variant"><tr id="type-exp.Var" class="anchored"><td class="def constructor"><a href="#type-exp.Var" class="anchor"></a><code>| </code><code><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bound" class="anchored"><td class="def constructor"><a href="#type-exp.Bound" class="anchor"></a><code>| </code><code><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bits" class="anchored"><td class="def constructor"><a href="#type-exp.Bits" class="anchor"></a><code>| </code><code><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bool" class="anchored"><td class="def constructor"><a href="#type-exp.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Enum" class="anchored"><td class="def constructor"><a href="#type-exp.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Unop" class="anchored"><td class="def constructor"><a href="#type-exp.Unop" class="anchor"></a><code>| </code><code><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Binop" class="anchored"><td class="def constructor"><a href="#type-exp.Binop" class="anchor"></a><code>| </code><code><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Manyop" class="anchored"><td class="def constructor"><a href="#type-exp.Manyop" class="anchor"></a><code>| </code><code><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Vec" class="anchored"><td class="def constructor"><a href="#type-exp.Vec" class="anchor"></a><code>| </code><code><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Ite" class="anchored"><td class="def constructor"><a href="#type-exp.Ite" class="anchor"></a><code>| </code><code><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Let" class="anchored"><td class="def constructor"><a href="#type-exp.Let" class="anchor"></a><code>| </code><code><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span>)</span> list</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> <span>'m ty</span></code><code> = </code><table class="variant"><tr id="type-ty.Ty_Mem" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Mem" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-ty.Ty_Bool" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Bool</span></code></td></tr><tr id="type-ty.Ty_BitVec" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code>| </code><code><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Enum" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Array" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Array" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr></table></dt><dt class="spec type" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></code><code> = </code><table class="variant"><tr id="type-smt.DeclareConst" class="anchored"><td class="def constructor"><a href="#type-smt.DeclareConst" class="anchor"></a><code>| </code><code><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr><tr id="type-smt.DefineConst" class="anchored"><td class="def constructor"><a href="#type-smt.DefineConst" class="anchor"></a><code>| </code><code><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Assert" class="anchored"><td class="def constructor"><a href="#type-smt.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Simplify" class="anchored"><td class="def constructor"><a href="#type-smt.Simplify" class="anchor"></a><code>| </code><code><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></code></td></tr><tr id="type-smt.Push" class="anchored"><td class="def constructor"><a href="#type-smt.Push" class="anchor"></a><code>| </code><code><span class="constructor">Push</span></code></td></tr><tr id="type-smt.Pop" class="anchored"><td class="def constructor"><a href="#type-smt.Pop" class="anchor"></a><code>| </code><code><span class="constructor">Pop</span></code></td></tr><tr id="type-smt.GetVersion" class="anchored"><td class="def constructor"><a href="#type-smt.GetVersion" class="anchor"></a><code>| </code><code><span class="constructor">GetVersion</span></code></td></tr><tr id="type-smt.CheckSat" class="anchored"><td class="def constructor"><a href="#type-smt.CheckSat" class="anchor"></a><code>| </code><code><span class="constructor">CheckSat</span></code></td></tr><tr id="type-smt.Exit" class="anchored"><td class="def constructor"><a href="#type-smt.Exit" class="anchor"></a><code>| </code><code><span class="constructor">Exit</span></code></td></tr></table></dt><dt class="spec type" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></code><code> = </code><table class="variant"><tr id="type-smt_ans.Error" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Error" class="anchor"></a><code>| </code><code><span class="constructor">Error</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Version" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Version" class="anchor"></a><code>| </code><code><span class="constructor">Version</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Sat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Sat" class="anchor"></a><code>| </code><code><span class="constructor">Sat</span></code></td></tr><tr id="type-smt_ans.Unsat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsat" class="anchor"></a><code>| </code><code><span class="constructor">Unsat</span></code></td></tr><tr id="type-smt_ans.Unknown" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unknown" class="anchor"></a><code>| </code><code><span class="constructor">Unknown</span></code></td></tr><tr id="type-smt_ans.Unsupported" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code>| </code><code><span class="constructor">Unsupported</span></code></td></tr><tr id="type-smt_ans.Exp" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Exp" class="anchor"></a><code>| </code><code><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr></table></dt></dl><aside><p>auxiliary functions on the new list types</p></aside><aside><p>library functions</p></aside><aside><p>subrules</p></aside><aside><p>auxiliary functions</p></aside><aside><p>free variables</p></aside><aside><p>substitutions</p></aside><aside><p>context application</p></aside><aside><p>definitions</p></aside></details></div></div></div><dl><dt class="spec type" id="type-no"><a href="#type-no" class="anchor"></a><code><span class="keyword">type</span> no</code><code> = </code><table class="variant"></table></dt><dd><p>Generic empty type. This kind of type is explained <a href="http://caml.inria.fr/pub/docs/manual-ocaml/emptyvariants.html">here</a>. In particular, when this type appear in a match case, the match case can contain a refutation pattern <code>.</code> to indicate that this impossible.</p><p>A refutation pattern also work with higher-level constructors, for example in this case:</p><pre><code class="ml">type a = A of int | B of no * int
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Ast (read-dwarf.Ast)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Ast</nav><header class="odoc-preamble"><h1>Module <code><span>Ast</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="Base/index.html">Base</a> <span class="keyword">end</span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../AstGen/Def/index.html">AstGen.Def</a> <span class="keyword">end</span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../AstGen/Ott/index.html">AstGen.Ott</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span><span class="keyword">type</span> bvar</span><span> = string</span></code></div><div class="spec-doc"><p>syntax</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span><span class="keyword">type</span> flag</span><span> = string</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span><span class="keyword">type</span> bvmanyarith</span><span> = <a href="../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a></span><span> = </span></code><ol><li id="type-bvmanyarith.Bvand" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvand</span></span></code></li><li id="type-bvmanyarith.Bvor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvor</span></span></code></li><li id="type-bvmanyarith.Bvxor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxor</span></span></code></li><li id="type-bvmanyarith.Bvadd" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvadd</span></span></code></li><li id="type-bvmanyarith.Bvmul" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmul</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binmem</span></span><span> = <span><span class="type-var">'m</span> <a href="../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span></span><span> = </span></code><ol><li id="type-binmem.Select" class="def variant constructor anchored"><a href="#type-binmem.Select" class="anchor"></a><code><span>| </span><span><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-binmem.Store" class="def variant constructor anchored"><a href="#type-binmem.Store" class="anchor"></a><code><span>| </span><span><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span><span class="keyword">type</span> bvcomp</span><span> = <a href="../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a></span><span> = </span></code><ol><li id="type-bvcomp.Bvult" class="def variant constructor anchored"><a href="#type-bvcomp.Bvult" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvult</span></span></code></li><li id="type-bvcomp.Bvslt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvslt</span></span></code></li><li id="type-bvcomp.Bvule" class="def variant constructor anchored"><a href="#type-bvcomp.Bvule" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvule</span></span></code></li><li id="type-bvcomp.Bvsle" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsle</span></span></code></li><li id="type-bvcomp.Bvuge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuge</span></span></code></li><li id="type-bvcomp.Bvsge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsge</span></span></code></li><li id="type-bvcomp.Bvugt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvugt</span></span></code></li><li id="type-bvcomp.Bvsgt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsgt</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span><span class="keyword">type</span> bvarith</span><span> = <a href="../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a></span><span> = </span></code><ol><li id="type-bvarith.Bvuremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuremi</span></span></code></li><li id="type-bvarith.Bvsremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsremi</span></span></code></li><li id="type-bvarith.Bvsmodi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmodi</span></span></code></li><li id="type-bvarith.Bvnand" class="def variant constructor anchored"><a href="#type-bvarith.Bvnand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnand</span></span></code></li><li id="type-bvarith.Bvnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnor</span></span></code></li><li id="type-bvarith.Bvxnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxnor</span></span></code></li><li id="type-bvarith.Bvsub" class="def variant constructor anchored"><a href="#type-bvarith.Bvsub" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsub</span></span></code></li><li id="type-bvarith.Bvudiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudiv</span></span></code></li><li id="type-bvarith.Bvudivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudivi</span></span></code></li><li id="type-bvarith.Bvsdiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdiv</span></span></code></li><li id="type-bvarith.Bvsdivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdivi</span></span></code></li><li id="type-bvarith.Bvurem" class="def variant constructor anchored"><a href="#type-bvarith.Bvurem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvurem</span></span></code></li><li id="type-bvarith.Bvsrem" class="def variant constructor anchored"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsrem</span></span></code></li><li id="type-bvarith.Bvsmod" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmod</span></span></code></li><li id="type-bvarith.Bvshl" class="def variant constructor anchored"><a href="#type-bvarith.Bvshl" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvshl</span></span></code></li><li id="type-bvarith.Bvlshr" class="def variant constructor anchored"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvlshr</span></span></code></li><li id="type-bvarith.Bvashr" class="def variant constructor anchored"><a href="#type-bvarith.Bvashr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvashr</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span><span class="keyword">type</span> manyop</span><span> = <a href="../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a></span><span> = </span></code><ol><li id="type-manyop.And" class="def variant constructor anchored"><a href="#type-manyop.And" class="anchor"></a><code><span>| </span><span><span class="constructor">And</span></span></code></li><li id="type-manyop.Or" class="def variant constructor anchored"><a href="#type-manyop.Or" class="anchor"></a><code><span>| </span><span><span class="constructor">Or</span></span></code></li><li id="type-manyop.Bvmanyarith" class="def variant constructor anchored"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="#type-bvmanyarith">bvmanyarith</a></span></code></li><li id="type-manyop.Concat" class="def variant constructor anchored"><a href="#type-manyop.Concat" class="anchor"></a><code><span>| </span><span><span class="constructor">Concat</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binop</span></span><span> = <span><span class="type-var">'m</span> <a href="../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span></span><span> = </span></code><ol><li id="type-binop.Binmem" class="def variant constructor anchored"><a href="#type-binop.Binmem" class="anchor"></a><code><span>| </span><span><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binmem">binmem</a></span></span></code></li><li id="type-binop.Eq" class="def variant constructor anchored"><a href="#type-binop.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span></span></code></li><li id="type-binop.Bvarith" class="def variant constructor anchored"><a href="#type-binop.Bvarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="#type-bvarith">bvarith</a></span></code></li><li id="type-binop.Bvcomp" class="def variant constructor anchored"><a href="#type-binop.Bvcomp" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="#type-bvcomp">bvcomp</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span><span class="keyword">type</span> unop</span><span> = <a href="../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a></span><span> = </span></code><ol><li id="type-unop.Not" class="def variant constructor anchored"><a href="#type-unop.Not" class="anchor"></a><code><span>| </span><span><span class="constructor">Not</span></span></code></li><li id="type-unop.Bvnot" class="def variant constructor anchored"><a href="#type-unop.Bvnot" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnot</span></span></code></li><li id="type-unop.Bvredand" class="def variant constructor anchored"><a href="#type-unop.Bvredand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredand</span></span></code></li><li id="type-unop.Bvredor" class="def variant constructor anchored"><a href="#type-unop.Bvredor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredor</span></span></code></li><li id="type-unop.Bvneg" class="def variant constructor anchored"><a href="#type-unop.Bvneg" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvneg</span></span></code></li><li id="type-unop.Extract" class="def variant constructor anchored"><a href="#type-unop.Extract" class="anchor"></a><code><span>| </span><span><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-unop.ZeroExtend" class="def variant constructor anchored"><a href="#type-unop.ZeroExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</span></code></li><li id="type-unop.SignExtend" class="def variant constructor anchored"><a href="#type-unop.SignExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></span><span> = </span></code><ol><li id="type-exp.Var" class="def variant constructor anchored"><a href="#type-exp.Var" class="anchor"></a><code><span>| </span><span><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bound" class="def variant constructor anchored"><a href="#type-exp.Bound" class="anchor"></a><code><span>| </span><span><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bits" class="def variant constructor anchored"><a href="#type-exp.Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bool" class="def variant constructor anchored"><a href="#type-exp.Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></span></code></li><li id="type-exp.Enum" class="def variant constructor anchored"><a href="#type-exp.Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Unop" class="def variant constructor anchored"><a href="#type-exp.Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Binop" class="def variant constructor anchored"><a href="#type-exp.Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Manyop" class="def variant constructor anchored"><a href="#type-exp.Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Vec" class="def variant constructor anchored"><a href="#type-exp.Vec" class="anchor"></a><code><span>| </span><span><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Ite" class="def variant constructor anchored"><a href="#type-exp.Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Let" class="def variant constructor anchored"><a href="#type-exp.Let" class="anchor"></a><code><span>| </span><span><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>)</span> list</span>
+  * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m ty</span></span><span> = <span><span class="type-var">'m</span> <a href="../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span></span><span> = </span></code><ol><li id="type-ty.Ty_Mem" class="def variant constructor anchored"><a href="#type-ty.Ty_Mem" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-ty.Ty_Bool" class="def variant constructor anchored"><a href="#type-ty.Ty_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Bool</span></span></code></li><li id="type-ty.Ty_BitVec" class="def variant constructor anchored"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Enum" class="def variant constructor anchored"><a href="#type-ty.Ty_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Array" class="def variant constructor anchored"><a href="#type-ty.Ty_Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span></span><span> = </span></code><ol><li id="type-smt.DeclareConst" class="def variant constructor anchored"><a href="#type-smt.DeclareConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li><li id="type-smt.DefineConst" class="def variant constructor anchored"><a href="#type-smt.DefineConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Assert" class="def variant constructor anchored"><a href="#type-smt.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Simplify" class="def variant constructor anchored"><a href="#type-smt.Simplify" class="anchor"></a><code><span>| </span><span><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></span></code></li><li id="type-smt.Push" class="def variant constructor anchored"><a href="#type-smt.Push" class="anchor"></a><code><span>| </span><span><span class="constructor">Push</span></span></code></li><li id="type-smt.Pop" class="def variant constructor anchored"><a href="#type-smt.Pop" class="anchor"></a><code><span>| </span><span><span class="constructor">Pop</span></span></code></li><li id="type-smt.GetVersion" class="def variant constructor anchored"><a href="#type-smt.GetVersion" class="anchor"></a><code><span>| </span><span><span class="constructor">GetVersion</span></span></code></li><li id="type-smt.CheckSat" class="def variant constructor anchored"><a href="#type-smt.CheckSat" class="anchor"></a><code><span>| </span><span><span class="constructor">CheckSat</span></span></code></li><li id="type-smt.Exit" class="def variant constructor anchored"><a href="#type-smt.Exit" class="anchor"></a><code><span>| </span><span><span class="constructor">Exit</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span></span><span> = </span></code><ol><li id="type-smt_ans.Error" class="def variant constructor anchored"><a href="#type-smt_ans.Error" class="anchor"></a><code><span>| </span><span><span class="constructor">Error</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Version" class="def variant constructor anchored"><a href="#type-smt_ans.Version" class="anchor"></a><code><span>| </span><span><span class="constructor">Version</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Sat" class="def variant constructor anchored"><a href="#type-smt_ans.Sat" class="anchor"></a><code><span>| </span><span><span class="constructor">Sat</span></span></code></li><li id="type-smt_ans.Unsat" class="def variant constructor anchored"><a href="#type-smt_ans.Unsat" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsat</span></span></code></li><li id="type-smt_ans.Unknown" class="def variant constructor anchored"><a href="#type-smt_ans.Unknown" class="anchor"></a><code><span>| </span><span><span class="constructor">Unknown</span></span></code></li><li id="type-smt_ans.Unsupported" class="def variant constructor anchored"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsupported</span></span></code></li><li id="type-smt_ans.Exp" class="def variant constructor anchored"><a href="#type-smt_ans.Exp" class="anchor"></a><code><span>| </span><span><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li></ol></div></div><p>auxiliary functions on the new list types</p><p>library functions</p><p>subrules</p><p>auxiliary functions</p><p>free variables</p><p>substitutions</p><p>context application</p><p>definitions</p></details></div><div class="odoc-spec"><div class="spec type anchored" id="type-no"><a href="#type-no" class="anchor"></a><code><span><span class="keyword">type</span> no</span><span> = <a href="../AstGen/Def/index.html#type-no">AstGen.Def.no</a></span><span> = </span><span>|</span></code></div><div class="spec-doc"><p>Generic empty type. This kind of type is explained <a href="http://caml.inria.fr/pub/docs/manual-ocaml/emptyvariants.html">here</a>. In particular, when this type appear in a match case, the match case can contain a refutation pattern <code>.</code> to indicate that this impossible.</p><p>A refutation pattern also work with higher-level constructors, for example in this case:</p><pre class="language-ocaml"><code>type a = A of int | B of no * int
 let f : a -&gt; int = function
   | A i -&gt; i
-  | B _ -&gt; .</code></pre><p>It also work in product types:</p><pre><code class="ml">let f : no * int -&gt; unit = function _ -&gt; . </code></pre><p>However it doesn't work for sum types: the <code>no</code> type need to appear directly in the pattern:</p><pre><code class="ml">type complex_empty = A of no | B of no
+  | B _ -&gt; .</code></pre><p>It also work in product types:</p><pre class="language-ocaml"><code> let f : no * int -&gt; unit = function _ -&gt; . </code></pre><p>However it doesn't work for sum types: the <code>no</code> type need to appear directly in the pattern:</p><pre class="language-ocaml"><code>type complex_empty = A of no | B of no
 let f : complex_empty = function _ -&gt; . (* does not compile *)
-let f : complex_empty = function A _ | B _ -&gt; . (* compiles *)</code></pre><p>In case this behavior is needed, there <a href="index.html#destr"><span>Destructors</span></a> in <a href="index.html"><code>Ast</code></a>. See this section to see how they are used.</p></dd></dl><dl><dt class="spec type" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span class="keyword">type</span> loc</code><code> = Stdlib.Lexing.position</code></dt><dd><p><a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Lexing.html#TYPEposition"><code>Lexing.position</code></a></p></dd></dl><dl><dt class="spec type" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span class="keyword">type</span> lrng</code><code> = Isla_lang.AST.lrng</code></dt><dd><p>The type of an expression range. This imported from Isla to avoid having two incompatible types.</p><p>This represent a range in a source file, so generally this is a pair of <a href="index.html#type-loc"><code>loc</code></a>, but it may also be <code>Unknown</code>.</p></dd></dl><div class="spec module" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span class="keyword">module</span> Size = <a href="../AstGen/Def/index.html#module-Size">AstGen.Def.Size</a></code></div><dl><dt class="spec type" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span class="keyword">type</span> rexp</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-exp">exp</a></span></code></dt><dd><p>Raw expression coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rty"><a href="#type-rty" class="anchor"></a><code><span class="keyword">type</span> rty</code><code> = <span><a href="Size/index.html#type-t">Size.t</a> <a href="index.html#type-ty">ty</a></span></code></dt><dd><p>Raw type coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span class="keyword">type</span> rsmt</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-smt">smt</a></span></code></dt><dd><p>Raw SMT command coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt_ans"><a href="#type-rsmt_ans" class="anchor"></a><code><span class="keyword">type</span> rsmt_ans</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-smt_ans">smt_ans</a></span></code></dt><dd><p>Raw SMT answer coming out of the parser</p></dd></dl></details></div></div></div><section><header><h2 id="size"><a href="#size" class="anchor"></a>Size</h2></header><div class="spec module" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span class="keyword">module</span> Size = <a href="Base/index.html#module-Size">Base.Size</a></code></div></section><section><header><h2 id="parsing"><a href="#parsing" class="anchor"></a>Parsing</h2></header><div class="spec module" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span class="keyword">module</span> Parser = <a href="../AstGen/index.html#module-Parser">AstGen.Parser</a></code></div><div class="spec module" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span class="keyword">module</span> Lexer = <a href="../AstGen/index.html#module-Lexer">AstGen.Lexer</a></code></div><dl><dt class="spec value" id="val-unknown"><a href="#val-unknown" class="anchor"></a><code><span class="keyword">val</span> unknown : Isla_lang.AST.lrng</code></dt><dt class="spec value" id="val-loc"><a href="#val-loc" class="anchor"></a><code><span class="keyword">val</span> loc : Stdlib.Lexing.position <span>&#45;&gt;</span> PPrint.document</code></dt></dl><dl><dt class="spec exception" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla parsing error</p></dd></dl><dl><dt class="spec exception" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">LexError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla lexing error</p></dd></dl><dl><dt class="spec type" id="type-lexbuf"><a href="#type-lexbuf" class="anchor"></a><code><span class="keyword">type</span> lexbuf</code><code> = Stdlib.Lexing.lexbuf</code></dt><dt class="spec type" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span class="keyword">type</span> lexer</code><code> = <a href="index.html#type-lexbuf">lexbuf</a> <span>&#45;&gt;</span> <a href="../AstGen/Parser/index.html#type-token">Parser.token</a></code></dt><dt class="spec type" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span class="keyword">type</span> <span>'a parser</span></code><code> = <a href="index.html#type-lexer">lexer</a> <span>&#45;&gt;</span> <a href="index.html#type-lexbuf">lexbuf</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec value" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span class="keyword">val</span> parse : <span><span class="type-var">'a</span> <a href="index.html#type-parser">parser</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="index.html#type-lexbuf">lexbuf</a>)</span> <span>&#45;&gt;</span> <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-from_string"><a href="#val-from_string" class="anchor"></a><code><span class="keyword">val</span> from_string : string <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf</code></dt><dt class="spec value" id="val-from_channel"><a href="#val-from_channel" class="anchor"></a><code><span class="keyword">val</span> from_channel : Stdlib.in_channel <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf</code></dt><dt class="spec value" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span class="keyword">val</span> parse_exp_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span><span>(<a href="../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></code></dt><dd><p>Parse a single Isla expression from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span class="keyword">val</span> parse_exp_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <span><span>(<a href="../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></code></dt><dd><p>Parse a single Isla expression from a channel</p></dd></dl><dl><dt class="spec value" id="val-parse_smt_ans_string"><a href="#val-parse_smt_ans_string" class="anchor"></a><code><span class="keyword">val</span> parse_smt_ans_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></code></dt><dd><p>Parse a single Isla expression from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_smt_ans_channel"><a href="#val-parse_smt_ans_channel" class="anchor"></a><code><span class="keyword">val</span> parse_smt_ans_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <a href="../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></code></dt><dd><p>Parse a single Isla expression from a channel</p></dd></dl><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../AstGen/index.html#module-Parser_pp">AstGen.Parser_pp</a></code></span></summary><dl><dt class="spec value" id="val-pp_raw_bvar"><a href="#val-pp_raw_bvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvf"><a href="#val-pp_raw_bvf" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvf : <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_flag"><a href="#val-pp_raw_flag" class="anchor"></a><code><span class="keyword">val</span> pp_raw_flag : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span class="keyword">val</span> pp_raw_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum : <a href="../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span class="keyword">val</span> pp_raw_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span class="keyword">val</span> pp_raw_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_mem_size"><a href="#val-pp_raw_mem_size" class="anchor"></a><code><span class="keyword">val</span> pp_raw_mem_size : <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_raw_binmem"><a href="#val-pp_raw_binmem" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binmem : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_var"><a href="#val-pp_raw_var" class="anchor"></a><code><span class="keyword">val</span> pp_raw_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bbvar"><a href="#val-pp_raw_bbvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bbvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bind"><a href="#val-pp_raw_bind" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bind : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_fbool"><a href="#val-pp_raw_fbool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_fbool : <span>(string * bool)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smts"><a href="#val-pp_raw_smts" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smts : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt_ans"><a href="#val-pp_raw_smt_ans" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt_ans : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_ty : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_unop : <a href="../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvarith : <a href="../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvcomp : <a href="../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binop : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvmanyarith : <a href="../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_manyop : <a href="../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvar"><a href="#val-pp_bvar" class="anchor"></a><code><span class="keyword">val</span> pp_bvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvf"><a href="#val-pp_bvf" class="anchor"></a><code><span class="keyword">val</span> pp_bvf : <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_flag"><a href="#val-pp_flag" class="anchor"></a><code><span class="keyword">val</span> pp_flag : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span class="keyword">val</span> pp_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span class="keyword">val</span> pp_enum : <a href="../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span class="keyword">val</span> pp_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span class="keyword">val</span> pp_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span class="keyword">val</span> pp_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span class="keyword">val</span> pp_j : int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_mem_size"><a href="#val-pp_mem_size" class="anchor"></a><code><span class="keyword">val</span> pp_mem_size : <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_binmem"><a href="#val-pp_binmem" class="anchor"></a><code><span class="keyword">val</span> pp_binmem : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_var"><a href="#val-pp_var" class="anchor"></a><code><span class="keyword">val</span> pp_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bbvar"><a href="#val-pp_bbvar" class="anchor"></a><code><span class="keyword">val</span> pp_bbvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bind"><a href="#val-pp_bind" class="anchor"></a><code><span class="keyword">val</span> pp_bind : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_fbool"><a href="#val-pp_fbool" class="anchor"></a><code><span class="keyword">val</span> pp_fbool : <span>(string * bool)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smts"><a href="#val-pp_smts" class="anchor"></a><code><span class="keyword">val</span> pp_smts : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt_ans"><a href="#val-pp_smt_ans" class="anchor"></a><code><span class="keyword">val</span> pp_smt_ans : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span class="keyword">val</span> pp_ty : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span class="keyword">val</span> pp_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span class="keyword">val</span> pp_unop : <a href="../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvarith : <a href="../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_bvcomp : <a href="../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span class="keyword">val</span> pp_binop : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvmanyarith : <a href="../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_manyop : <a href="../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-pp_loc"><a href="#val-pp_loc" class="anchor"></a><code><span class="keyword">val</span> pp_loc : Stdlib.Lexing.position <span>&#45;&gt;</span> PPrint.document</code></dt><dd><p>Prints a lexing location</p></dd></dl><dl><dt class="spec value" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span class="keyword">val</span> pp_lrng : Isla_lang.AST.lrng <span>&#45;&gt;</span> PPrint.document</code></dt><dd><p>Prints a lexing range</p></dd></dl></section><section><header><h2 id="analysers"><a href="#analysers" class="anchor"></a>Analysers</h2><p>All function that start with <code>is_</code></p></header><dl><dt class="spec value" id="val-is_atomic"><a href="#val-is_atomic" class="anchor"></a><code><span class="keyword">val</span> is_atomic : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> bool</code></dt></dl></section><section><header><h2 id="destr"><a href="#destr" class="anchor"></a>Destructors</h2><p>Aparently I overestimated ocaml type-system in it's handling of empty types.</p><p>Here are some function to destroy empty types.</p></header><dl><dt class="spec value" id="val-destr_binmem"><a href="#val-destr_binmem" class="anchor"></a><code><span class="keyword">val</span> destr_binmem : <span><a href="index.html#type-no">no</a> <a href="index.html#type-binmem">binmem</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl></section><section><header><h2 id="expectors"><a href="#expectors" class="anchor"></a>Expectors</h2><p>Functions to assert that a specific constructor is used and get the value</p></header><dl><dt class="spec value" id="val-expect_bits"><a href="#val-expect_bits" class="anchor"></a><code><span class="keyword">val</span> expect_bits : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></code></dt><dt class="spec value" id="val-ty_expect_bv"><a href="#val-ty_expect_bv" class="anchor"></a><code><span class="keyword">val</span> ty_expect_bv : <span><span class="type-var">'a</span> <a href="index.html#type-ty">ty</a></span> <span>&#45;&gt;</span> int</code></dt></dl></section><section><header><h2 id="construtors"><a href="#construtors" class="anchor"></a>Construtors</h2></header><dl><dt class="spec value" id="val-assert_smt"><a href="#val-assert_smt" class="anchor"></a><code><span class="keyword">val</span> assert_smt : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-smt">smt</a></span></code></dt><dt class="spec value" id="val-simplify_smt"><a href="#val-simplify_smt" class="anchor"></a><code><span class="keyword">val</span> simplify_smt : <span>?&#8288;flags:<span><span>(string * bool)</span> list</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-smt">smt</a></span></code></dt></dl></section><section><header><h2 id="comparisons"><a href="#comparisons" class="anchor"></a>Comparisons</h2></header><dl><dt class="spec value" id="val-equal_exp"><a href="#val-equal_exp" class="anchor"></a><code><span class="keyword">val</span> equal_exp : <span>?&#8288;annot:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>var:<span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>?&#8288;bnd:<span>(<span class="type-var">'c</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality for expressions; default polymorphic equality will fail.</p></dd></dl></section></details></div></div></div><dl><dt class="spec module" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span class="keyword">module</span> <a href="Base/index.html">Base</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The main module to use the AST of expression and SMT operation for a more generic overview of the AST, see <a href="../SymbolicExpressions.html"><code>SymbolicExpressions</code></a>.</p></dd></dl><dl><dt class="spec module" id="module-Manip"><a href="#module-Manip" class="anchor"></a><code><span class="keyword">module</span> <a href="Manip/index.html">Manip</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide generic facilities of expression and SMT statements provided by <a href="index.html"><code>Ast</code></a>. It is intended to only provide syntactic facilities over <a href="index.html"><code>Ast</code></a> types, in particular <a href="index.html#type-exp"><code>Ast.exp</code></a>.</p></dd></dl></div></body></html>
\ No newline at end of file
+let f : complex_empty = function A _ | B _ -&gt; . (* compiles *)</code></pre><p>In case this behavior is needed, there <a href="#destr" title="destr">Destructors</a> in <a href="#"><code>Ast</code></a>. See this section to see how they are used.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span><span class="keyword">type</span> loc</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></div><div class="spec-doc"><p><a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Lexing.html#TYPEposition"><code>Lexing.position</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span><span class="keyword">type</span> lrng</span><span> = <span class="xref-unresolved">Isla_lang</span>.AST.lrng</span></code></div><div class="spec-doc"><p>The type of an expression range. This imported from Isla to avoid having two incompatible types.</p><p>This represent a range in a source file, so generally this is a pair of <a href="#val-loc"><code>loc</code></a>, but it may also be <code>Unknown</code>.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span><span class="keyword">type</span> rexp</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="Base/Size/index.html#type-t">Base.Size.t</a>)</span> <a href="#type-exp">exp</a></span></span></code></div><div class="spec-doc"><p>Raw expression coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rty"><a href="#type-rty" class="anchor"></a><code><span><span class="keyword">type</span> rty</span><span> = <span><a href="Base/Size/index.html#type-t">Base.Size.t</a> <a href="#type-ty">ty</a></span></span></code></div><div class="spec-doc"><p>Raw type coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span><span class="keyword">type</span> rsmt</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="Base/Size/index.html#type-t">Base.Size.t</a>)</span> <a href="#type-smt">smt</a></span></span></code></div><div class="spec-doc"><p>Raw SMT command coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt_ans"><a href="#type-rsmt_ans" class="anchor"></a><code><span><span class="keyword">type</span> rsmt_ans</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="Base/Size/index.html#type-t">Base.Size.t</a>)</span> <a href="#type-smt_ans">smt_ans</a></span></span></code></div><div class="spec-doc"><p>Raw SMT answer coming out of the parser</p></div></div></details></div><h2 id="size"><a href="#size" class="anchor"></a>Size</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span><span class="keyword">module</span> Size</span><span> = <a href="Base/Size/index.html">Base.Size</a></span></code></div></div><h2 id="parsing"><a href="#parsing" class="anchor"></a>Parsing</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span><span class="keyword">module</span> Parser</span><span> = <a href="../AstGen/Parser/index.html">AstGen.Parser</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span><span class="keyword">module</span> Lexer</span><span> = <a href="../AstGen/Lexer/index.html">AstGen.Lexer</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unknown"><a href="#val-unknown" class="anchor"></a><code><span><span class="keyword">val</span> unknown : <span class="xref-unresolved">Isla_lang</span>.AST.lrng</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-loc"><a href="#val-loc" class="anchor"></a><code><span><span class="keyword">val</span> loc : <span><span class="xref-unresolved">Stdlib</span>.Lexing.position <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla parsing error</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">LexError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla lexing error</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lexbuf"><a href="#type-lexbuf" class="anchor"></a><code><span><span class="keyword">type</span> lexbuf</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span><span class="keyword">type</span> lexer</span><span> = <span><a href="#type-lexbuf">lexbuf</a> <span class="arrow">&#45;&gt;</span></span> <a href="../AstGen/Parser/index.html#type-token">Parser.token</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a parser</span></span><span> = <span><a href="#type-lexer">lexer</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-lexbuf">lexbuf</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span><span class="keyword">val</span> parse : <span><span><span class="type-var">'a</span> <a href="#type-parser">parser</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-lexbuf">lexbuf</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from_string"><a href="#val-from_string" class="anchor"></a><code><span><span class="keyword">val</span> from_string : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from_channel"><a href="#val-from_channel" class="anchor"></a><code><span><span class="keyword">val</span> from_channel : <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_string : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_channel : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../AstGen/Def/index.html#type-lrng">AstGen.Def.lrng</a>, string, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_smt_ans_string"><a href="#val-parse_smt_ans_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_smt_ans_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_smt_ans_channel"><a href="#val-parse_smt_ans_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_smt_ans_channel : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span>
+  <a href="../AstGen/Def/index.html#type-rsmt_ans">AstGen.Def.rsmt_ans</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a channel</p></div></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../AstGen/Parser_pp/index.html">AstGen.Parser_pp</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvar"><a href="#val-pp_raw_bvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvf"><a href="#val-pp_raw_bvf" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvf : <span><a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_flag"><a href="#val-pp_raw_flag" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_flag : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum : <span><a href="../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_nat"><a href="#val-pp_raw_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_mem_size"><a href="#val-pp_raw_mem_size" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_mem_size : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binmem"><a href="#val-pp_raw_binmem" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binmem : <span><span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_var"><a href="#val-pp_raw_var" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_var : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bbvar"><a href="#val-pp_raw_bbvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bbvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bind"><a href="#val-pp_raw_bind" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bind : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_fbool"><a href="#val-pp_raw_fbool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_fbool : <span><span>(string * bool)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smts"><a href="#val-pp_raw_smts" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smts : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt_ans"><a href="#val-pp_raw_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt_ans : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_ty : <span><span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_unop : <span><a href="../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvarith : <span><a href="../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvcomp : <span><a href="../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binop : <span><span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvmanyarith : <span><a href="../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_manyop : <span><a href="../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvar"><a href="#val-pp_bvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvf"><a href="#val-pp_bvf" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvf : <span><a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_flag"><a href="#val-pp_flag" class="anchor"></a><code><span><span class="keyword">val</span> pp_flag : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum : <span><a href="../AstGen/Ott/index.html#type-enum">AstGen.Ott.enum</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_nat"><a href="#val-pp_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span><span class="keyword">val</span> pp_j : <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_mem_size"><a href="#val-pp_mem_size" class="anchor"></a><code><span><span class="keyword">val</span> pp_mem_size : <span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binmem"><a href="#val-pp_binmem" class="anchor"></a><code><span><span class="keyword">val</span> pp_binmem : <span><span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binmem">AstGen.Ott.binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_var"><a href="#val-pp_var" class="anchor"></a><code><span><span class="keyword">val</span> pp_var : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bbvar"><a href="#val-pp_bbvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bbvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bind"><a href="#val-pp_bind" class="anchor"></a><code><span><span class="keyword">val</span> pp_bind : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-exp">AstGen.Ott.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_fbool"><a href="#val-pp_fbool" class="anchor"></a><code><span><span class="keyword">val</span> pp_fbool : <span><span>(string * bool)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smts"><a href="#val-pp_smts" class="anchor"></a><code><span><span class="keyword">val</span> pp_smts : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt_ans"><a href="#val-pp_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt_ans : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt_ans">AstGen.Ott.smt_ans</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_ty : <span><span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-ty">AstGen.Ott.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_unop : <span><a href="../AstGen/Ott/index.html#type-unop">AstGen.Ott.unop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvarith : <span><a href="../AstGen/Ott/index.html#type-bvarith">AstGen.Ott.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvcomp : <span><a href="../AstGen/Ott/index.html#type-bvcomp">AstGen.Ott.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_binop : <span><span><a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a> <a href="../AstGen/Ott/index.html#type-binop">AstGen.Ott.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvmanyarith : <span><a href="../AstGen/Ott/index.html#type-bvmanyarith">AstGen.Ott.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_manyop : <span><a href="../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_loc"><a href="#val-pp_loc" class="anchor"></a><code><span><span class="keyword">val</span> pp_loc : <span><span class="xref-unresolved">Stdlib</span>.Lexing.position <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Prints a lexing location</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span><span class="keyword">val</span> pp_lrng : <span><span class="xref-unresolved">Isla_lang</span>.AST.lrng <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Prints a lexing range</p></div></div><h2 id="analysers"><a href="#analysers" class="anchor"></a>Analysers</h2><p>All function that start with <code>is_</code></p><div class="odoc-spec"><div class="spec value anchored" id="val-is_atomic"><a href="#val-is_atomic" class="anchor"></a><code><span><span class="keyword">val</span> is_atomic : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><h2 id="destr"><a href="#destr" class="anchor"></a>Destructors</h2><p>Aparently I overestimated ocaml type-system in it's handling of empty types.</p><p>Here are some function to destroy empty types.</p><div class="odoc-spec"><div class="spec value anchored" id="val-destr_binmem"><a href="#val-destr_binmem" class="anchor"></a><code><span><span class="keyword">val</span> destr_binmem : <span><span><a href="#type-no">no</a> <a href="#type-binmem">binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><h2 id="expectors"><a href="#expectors" class="anchor"></a>Expectors</h2><p>Functions to assert that a specific constructor is used and get the value</p><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bits"><a href="#val-expect_bits" class="anchor"></a><code><span><span class="keyword">val</span> expect_bits : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty_expect_bv"><a href="#val-ty_expect_bv" class="anchor"></a><code><span><span class="keyword">val</span> ty_expect_bv : <span><span><span class="type-var">'a</span> <a href="#type-ty">ty</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><h2 id="construtors"><a href="#construtors" class="anchor"></a>Construtors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-assert_smt"><a href="#val-assert_smt" class="anchor"></a><code><span><span class="keyword">val</span> assert_smt : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-smt">smt</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_smt"><a href="#val-simplify_smt" class="anchor"></a><code><span><span class="keyword">val</span> simplify_smt : 
+  <span><span class="optlabel">?flags</span>:<span><span>(string * bool)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-smt">smt</a></span></span></code></div></div><h2 id="comparisons"><a href="#comparisons" class="anchor"></a>Comparisons</h2><div class="odoc-spec"><div class="spec value anchored" id="val-equal_exp"><a href="#val-equal_exp" class="anchor"></a><code><span><span class="keyword">val</span> equal_exp : 
+  <span><span class="optlabel">?annot</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">var</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?bnd</span>:<span>(<span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  bool</span></code></div><div class="spec-doc"><p>Equality for expressions; default polymorphic equality will fail.</p></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Base/index.html">Base</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The main module to use the AST of expression and SMT operation for a more generic overview of the AST, see <a href="../SymbolicExpressions.html"><code>SymbolicExpressions</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Manip"><a href="#module-Manip" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Manip/index.html">Manip</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide generic facilities of expression and SMT statements provided by <a href="#"><code>Ast</code></a>. It is intended to only provide syntactic facilities over <a href="#"><code>Ast</code></a> types, in particular <a href="#type-exp"><code>Ast.exp</code></a>.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/Def/Size/index.html b/doc/html/read-dwarf/AstGen/Def/Size/index.html
index 0c37c020..bdc9c6a9 100644
--- a/doc/html/read-dwarf/AstGen/Def/Size/index.html
+++ b/doc/html/read-dwarf/AstGen/Def/Size/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Size (read-dwarf.AstGen.Def.Size)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">AstGen</a> &#x00BB; <a href="../index.html">Def</a> &#x00BB; Size</nav><h1>Module <code>Def.Size</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.B8" class="anchored"><td class="def constructor"><a href="#type-t.B8" class="anchor"></a><code>| </code><code><span class="constructor">B8</span></code></td></tr><tr id="type-t.B16" class="anchored"><td class="def constructor"><a href="#type-t.B16" class="anchor"></a><code>| </code><code><span class="constructor">B16</span></code></td></tr><tr id="type-t.B32" class="anchored"><td class="def constructor"><a href="#type-t.B32" class="anchor"></a><code>| </code><code><span class="constructor">B32</span></code></td></tr><tr id="type-t.B64" class="anchored"><td class="def constructor"><a href="#type-t.B64" class="anchor"></a><code>| </code><code><span class="constructor">B64</span></code></td></tr></table></dt><dd><p>The possible sizes for memory accesses. It may be necessary to add <code>B128</code> at some point</p></dd></dl><dl><dt class="spec value" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span class="keyword">val</span> of_bytes : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a size value from a valid size in byte</p></dd></dl><dl><dt class="spec value" id="val-of_bits"><a href="#val-of_bits" class="anchor"></a><code><span class="keyword">val</span> of_bits : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a size value from a valid size in bits</p></dd></dl><dl><dt class="spec value" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span class="keyword">val</span> to_bytes : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the byte size corresponding to that value</p></dd></dl><dl><dt class="spec value" id="val-to_bits"><a href="#val-to_bits" class="anchor"></a><code><span class="keyword">val</span> to_bits : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the bits size corresponding to that value</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-pp_bytes"><a href="#val-pp_bytes" class="anchor"></a><code><span class="keyword">val</span> pp_bytes : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty-print a size as just the byte number</p></dd></dl><dl><dt class="spec value" id="val-pp_bits"><a href="#val-pp_bits" class="anchor"></a><code><span class="keyword">val</span> pp_bits : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty print a size at &quot;16bits&quot; for example</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Size (read-dwarf.AstGen.Def.Size)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">AstGen</a> &#x00BB; <a href="../index.html">Def</a> &#x00BB; Size</nav><header class="odoc-preamble"><h1>Module <code><span>Def.Size</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.B8" class="def variant constructor anchored"><a href="#type-t.B8" class="anchor"></a><code><span>| </span><span><span class="constructor">B8</span></span></code></li><li id="type-t.B16" class="def variant constructor anchored"><a href="#type-t.B16" class="anchor"></a><code><span>| </span><span><span class="constructor">B16</span></span></code></li><li id="type-t.B32" class="def variant constructor anchored"><a href="#type-t.B32" class="anchor"></a><code><span>| </span><span><span class="constructor">B32</span></span></code></li><li id="type-t.B64" class="def variant constructor anchored"><a href="#type-t.B64" class="anchor"></a><code><span>| </span><span><span class="constructor">B64</span></span></code></li><li id="type-t.B128" class="def variant constructor anchored"><a href="#type-t.B128" class="anchor"></a><code><span>| </span><span><span class="constructor">B128</span></span></code></li></ol></div><div class="spec-doc"><p>The possible sizes for memory accesses.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span><span class="keyword">val</span> of_bytes : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a size value from a valid size in byte</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bits"><a href="#val-of_bits" class="anchor"></a><code><span><span class="keyword">val</span> of_bits : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a size value from a valid size in bits</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span><span class="keyword">val</span> to_bytes : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the byte size corresponding to that value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bits"><a href="#val-to_bits" class="anchor"></a><code><span><span class="keyword">val</span> to_bits : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the bits size corresponding to that value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bytes"><a href="#val-pp_bytes" class="anchor"></a><code><span><span class="keyword">val</span> pp_bytes : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty-print a size as just the byte number</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bits"><a href="#val-pp_bits" class="anchor"></a><code><span><span class="keyword">val</span> pp_bits : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a size at &quot;16bits&quot; for example</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/Def/index.html b/doc/html/read-dwarf/AstGen/Def/index.html
index 36f4a134..19c96b33 100644
--- a/doc/html/read-dwarf/AstGen/Def/index.html
+++ b/doc/html/read-dwarf/AstGen/Def/index.html
@@ -1,7 +1,10 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Def (read-dwarf.AstGen.Def)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Def</nav><h1>Module <code>AstGen.Def</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../index.html#module-Ott">Ott</a></code></span></summary><aside><p>warning: the backend selected ignores the file structure informations</p></aside><dl><dt class="spec type" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span class="keyword">type</span> bvar</code><code> = string</code></dt><dd><p>syntax</p></dd></dl><dl><dt class="spec type" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span class="keyword">type</span> flag</code><code> = string</code></dt><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = int * int</code></dt><dt class="spec type" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span class="keyword">type</span> <span>'m binmem</span></code><code> = </code><table class="variant"><tr id="type-binmem.Select" class="anchored"><td class="def constructor"><a href="#type-binmem.Select" class="anchor"></a><code>| </code><code><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-binmem.Store" class="anchored"><td class="def constructor"><a href="#type-binmem.Store" class="anchor"></a><code>| </code><code><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr></table></dt><dt class="spec type" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span class="keyword">type</span> bvarith</code><code> = </code><table class="variant"><tr id="type-bvarith.Bvuremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvuremi</span></code></td></tr><tr id="type-bvarith.Bvsremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsremi</span></code></td></tr><tr id="type-bvarith.Bvsmodi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmodi</span></code></td></tr><tr id="type-bvarith.Bvnand" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnand" class="anchor"></a><code>| </code><code><span class="constructor">Bvnand</span></code></td></tr><tr id="type-bvarith.Bvnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvnor</span></code></td></tr><tr id="type-bvarith.Bvxnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxnor</span></code></td></tr><tr id="type-bvarith.Bvsub" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsub" class="anchor"></a><code>| </code><code><span class="constructor">Bvsub</span></code></td></tr><tr id="type-bvarith.Bvudiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvudiv</span></code></td></tr><tr id="type-bvarith.Bvudivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvudivi</span></code></td></tr><tr id="type-bvarith.Bvsdiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdiv</span></code></td></tr><tr id="type-bvarith.Bvsdivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdivi</span></code></td></tr><tr id="type-bvarith.Bvurem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvurem" class="anchor"></a><code>| </code><code><span class="constructor">Bvurem</span></code></td></tr><tr id="type-bvarith.Bvsrem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code>| </code><code><span class="constructor">Bvsrem</span></code></td></tr><tr id="type-bvarith.Bvsmod" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmod</span></code></td></tr><tr id="type-bvarith.Bvshl" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvshl" class="anchor"></a><code>| </code><code><span class="constructor">Bvshl</span></code></td></tr><tr id="type-bvarith.Bvlshr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code>| </code><code><span class="constructor">Bvlshr</span></code></td></tr><tr id="type-bvarith.Bvashr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvashr" class="anchor"></a><code>| </code><code><span class="constructor">Bvashr</span></code></td></tr></table></dt><dt class="spec type" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span class="keyword">type</span> bvcomp</code><code> = </code><table class="variant"><tr id="type-bvcomp.Bvult" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvult" class="anchor"></a><code>| </code><code><span class="constructor">Bvult</span></code></td></tr><tr id="type-bvcomp.Bvslt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code>| </code><code><span class="constructor">Bvslt</span></code></td></tr><tr id="type-bvcomp.Bvule" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvule" class="anchor"></a><code>| </code><code><span class="constructor">Bvule</span></code></td></tr><tr id="type-bvcomp.Bvsle" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code>| </code><code><span class="constructor">Bvsle</span></code></td></tr><tr id="type-bvcomp.Bvuge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code>| </code><code><span class="constructor">Bvuge</span></code></td></tr><tr id="type-bvcomp.Bvsge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code>| </code><code><span class="constructor">Bvsge</span></code></td></tr><tr id="type-bvcomp.Bvugt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code>| </code><code><span class="constructor">Bvugt</span></code></td></tr><tr id="type-bvcomp.Bvsgt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code>| </code><code><span class="constructor">Bvsgt</span></code></td></tr></table></dt><dt class="spec type" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span class="keyword">type</span> bvmanyarith</code><code> = </code><table class="variant"><tr id="type-bvmanyarith.Bvand" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code>| </code><code><span class="constructor">Bvand</span></code></td></tr><tr id="type-bvmanyarith.Bvor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code>| </code><code><span class="constructor">Bvor</span></code></td></tr><tr id="type-bvmanyarith.Bvxor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxor</span></code></td></tr><tr id="type-bvmanyarith.Bvadd" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code>| </code><code><span class="constructor">Bvadd</span></code></td></tr><tr id="type-bvmanyarith.Bvmul" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code>| </code><code><span class="constructor">Bvmul</span></code></td></tr></table></dt><dt class="spec type" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span class="keyword">type</span> unop</code><code> = </code><table class="variant"><tr id="type-unop.Not" class="anchored"><td class="def constructor"><a href="#type-unop.Not" class="anchor"></a><code>| </code><code><span class="constructor">Not</span></code></td></tr><tr id="type-unop.Bvnot" class="anchored"><td class="def constructor"><a href="#type-unop.Bvnot" class="anchor"></a><code>| </code><code><span class="constructor">Bvnot</span></code></td></tr><tr id="type-unop.Bvredand" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredand" class="anchor"></a><code>| </code><code><span class="constructor">Bvredand</span></code></td></tr><tr id="type-unop.Bvredor" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredor" class="anchor"></a><code>| </code><code><span class="constructor">Bvredor</span></code></td></tr><tr id="type-unop.Bvneg" class="anchored"><td class="def constructor"><a href="#type-unop.Bvneg" class="anchor"></a><code>| </code><code><span class="constructor">Bvneg</span></code></td></tr><tr id="type-unop.Extract" class="anchored"><td class="def constructor"><a href="#type-unop.Extract" class="anchor"></a><code>| </code><code><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-unop.ZeroExtend" class="anchored"><td class="def constructor"><a href="#type-unop.ZeroExtend" class="anchor"></a><code>| </code><code><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-unop.SignExtend" class="anchored"><td class="def constructor"><a href="#type-unop.SignExtend" class="anchor"></a><code>| </code><code><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span class="keyword">type</span> <span>'m binop</span></code><code> = </code><table class="variant"><tr id="type-binop.Binmem" class="anchored"><td class="def constructor"><a href="#type-binop.Binmem" class="anchor"></a><code>| </code><code><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binmem">binmem</a></span></code></td></tr><tr id="type-binop.Eq" class="anchored"><td class="def constructor"><a href="#type-binop.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span></code></td></tr><tr id="type-binop.Bvarith" class="anchored"><td class="def constructor"><a href="#type-binop.Bvarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="index.html#type-bvarith">bvarith</a></code></td></tr><tr id="type-binop.Bvcomp" class="anchored"><td class="def constructor"><a href="#type-binop.Bvcomp" class="anchor"></a><code>| </code><code><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="index.html#type-bvcomp">bvcomp</a></code></td></tr></table></dt><dt class="spec type" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span class="keyword">type</span> manyop</code><code> = </code><table class="variant"><tr id="type-manyop.And" class="anchored"><td class="def constructor"><a href="#type-manyop.And" class="anchor"></a><code>| </code><code><span class="constructor">And</span></code></td></tr><tr id="type-manyop.Or" class="anchored"><td class="def constructor"><a href="#type-manyop.Or" class="anchor"></a><code>| </code><code><span class="constructor">Or</span></code></td></tr><tr id="type-manyop.Bvmanyarith" class="anchored"><td class="def constructor"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="index.html#type-bvmanyarith">bvmanyarith</a></code></td></tr><tr id="type-manyop.Concat" class="anchored"><td class="def constructor"><a href="#type-manyop.Concat" class="anchor"></a><code>| </code><code><span class="constructor">Concat</span></code></td></tr></table></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></code><code> = </code><table class="variant"><tr id="type-exp.Var" class="anchored"><td class="def constructor"><a href="#type-exp.Var" class="anchor"></a><code>| </code><code><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bound" class="anchored"><td class="def constructor"><a href="#type-exp.Bound" class="anchor"></a><code>| </code><code><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bits" class="anchored"><td class="def constructor"><a href="#type-exp.Bits" class="anchor"></a><code>| </code><code><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bool" class="anchored"><td class="def constructor"><a href="#type-exp.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Enum" class="anchored"><td class="def constructor"><a href="#type-exp.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Unop" class="anchored"><td class="def constructor"><a href="#type-exp.Unop" class="anchor"></a><code>| </code><code><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Binop" class="anchored"><td class="def constructor"><a href="#type-exp.Binop" class="anchor"></a><code>| </code><code><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Manyop" class="anchored"><td class="def constructor"><a href="#type-exp.Manyop" class="anchor"></a><code>| </code><code><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Vec" class="anchored"><td class="def constructor"><a href="#type-exp.Vec" class="anchor"></a><code>| </code><code><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Ite" class="anchored"><td class="def constructor"><a href="#type-exp.Ite" class="anchor"></a><code>| </code><code><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Let" class="anchored"><td class="def constructor"><a href="#type-exp.Let" class="anchor"></a><code>| </code><code><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span>)</span> list</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> <span>'m ty</span></code><code> = </code><table class="variant"><tr id="type-ty.Ty_Mem" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Mem" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-ty.Ty_Bool" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Bool</span></code></td></tr><tr id="type-ty.Ty_BitVec" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code>| </code><code><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Enum" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Array" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Array" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr></table></dt><dt class="spec type" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></code><code> = </code><table class="variant"><tr id="type-smt.DeclareConst" class="anchored"><td class="def constructor"><a href="#type-smt.DeclareConst" class="anchor"></a><code>| </code><code><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr><tr id="type-smt.DefineConst" class="anchored"><td class="def constructor"><a href="#type-smt.DefineConst" class="anchor"></a><code>| </code><code><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Assert" class="anchored"><td class="def constructor"><a href="#type-smt.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Simplify" class="anchored"><td class="def constructor"><a href="#type-smt.Simplify" class="anchor"></a><code>| </code><code><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></code></td></tr><tr id="type-smt.Push" class="anchored"><td class="def constructor"><a href="#type-smt.Push" class="anchor"></a><code>| </code><code><span class="constructor">Push</span></code></td></tr><tr id="type-smt.Pop" class="anchored"><td class="def constructor"><a href="#type-smt.Pop" class="anchor"></a><code>| </code><code><span class="constructor">Pop</span></code></td></tr><tr id="type-smt.GetVersion" class="anchored"><td class="def constructor"><a href="#type-smt.GetVersion" class="anchor"></a><code>| </code><code><span class="constructor">GetVersion</span></code></td></tr><tr id="type-smt.CheckSat" class="anchored"><td class="def constructor"><a href="#type-smt.CheckSat" class="anchor"></a><code>| </code><code><span class="constructor">CheckSat</span></code></td></tr><tr id="type-smt.Exit" class="anchored"><td class="def constructor"><a href="#type-smt.Exit" class="anchor"></a><code>| </code><code><span class="constructor">Exit</span></code></td></tr></table></dt><dt class="spec type" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></code><code> = </code><table class="variant"><tr id="type-smt_ans.Error" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Error" class="anchor"></a><code>| </code><code><span class="constructor">Error</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Version" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Version" class="anchor"></a><code>| </code><code><span class="constructor">Version</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Sat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Sat" class="anchor"></a><code>| </code><code><span class="constructor">Sat</span></code></td></tr><tr id="type-smt_ans.Unsat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsat" class="anchor"></a><code>| </code><code><span class="constructor">Unsat</span></code></td></tr><tr id="type-smt_ans.Unknown" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unknown" class="anchor"></a><code>| </code><code><span class="constructor">Unknown</span></code></td></tr><tr id="type-smt_ans.Unsupported" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code>| </code><code><span class="constructor">Unsupported</span></code></td></tr><tr id="type-smt_ans.Exp" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Exp" class="anchor"></a><code>| </code><code><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr></table></dt></dl><aside><p>auxiliary functions on the new list types</p></aside><aside><p>library functions</p></aside><aside><p>subrules</p></aside><aside><p>auxiliary functions</p></aside><aside><p>free variables</p></aside><aside><p>substitutions</p></aside><aside><p>context application</p></aside><aside><p>definitions</p></aside></details></div></div></div><dl><dt class="spec type" id="type-no"><a href="#type-no" class="anchor"></a><code><span class="keyword">type</span> no</code><code> = </code><table class="variant"></table></dt><dd><p>Generic empty type. This kind of type is explained <a href="http://caml.inria.fr/pub/docs/manual-ocaml/emptyvariants.html">here</a>. In particular, when this type appear in a match case, the match case can contain a refutation pattern <code>.</code> to indicate that this impossible.</p><p>A refutation pattern also work with higher-level constructors, for example in this case:</p><pre><code class="ml">type a = A of int | B of no * int
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Def (read-dwarf.AstGen.Def)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Def</nav><header class="odoc-preamble"><h1>Module <code><span>AstGen.Def</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../Ott/index.html">Ott</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span><span class="keyword">type</span> bvar</span><span> = string</span></code></div><div class="spec-doc"><p>syntax</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span><span class="keyword">type</span> flag</span><span> = string</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span><span class="keyword">type</span> bvmanyarith</span><span> = <a href="../Ott/index.html#type-bvmanyarith">Ott.bvmanyarith</a></span><span> = </span></code><ol><li id="type-bvmanyarith.Bvand" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvand</span></span></code></li><li id="type-bvmanyarith.Bvor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvor</span></span></code></li><li id="type-bvmanyarith.Bvxor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxor</span></span></code></li><li id="type-bvmanyarith.Bvadd" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvadd</span></span></code></li><li id="type-bvmanyarith.Bvmul" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmul</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binmem</span></span><span> = <span><span class="type-var">'m</span> <a href="../Ott/index.html#type-binmem">Ott.binmem</a></span></span><span> = </span></code><ol><li id="type-binmem.Select" class="def variant constructor anchored"><a href="#type-binmem.Select" class="anchor"></a><code><span>| </span><span><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-binmem.Store" class="def variant constructor anchored"><a href="#type-binmem.Store" class="anchor"></a><code><span>| </span><span><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span><span class="keyword">type</span> bvcomp</span><span> = <a href="../Ott/index.html#type-bvcomp">Ott.bvcomp</a></span><span> = </span></code><ol><li id="type-bvcomp.Bvult" class="def variant constructor anchored"><a href="#type-bvcomp.Bvult" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvult</span></span></code></li><li id="type-bvcomp.Bvslt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvslt</span></span></code></li><li id="type-bvcomp.Bvule" class="def variant constructor anchored"><a href="#type-bvcomp.Bvule" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvule</span></span></code></li><li id="type-bvcomp.Bvsle" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsle</span></span></code></li><li id="type-bvcomp.Bvuge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuge</span></span></code></li><li id="type-bvcomp.Bvsge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsge</span></span></code></li><li id="type-bvcomp.Bvugt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvugt</span></span></code></li><li id="type-bvcomp.Bvsgt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsgt</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span><span class="keyword">type</span> bvarith</span><span> = <a href="../Ott/index.html#type-bvarith">Ott.bvarith</a></span><span> = </span></code><ol><li id="type-bvarith.Bvuremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuremi</span></span></code></li><li id="type-bvarith.Bvsremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsremi</span></span></code></li><li id="type-bvarith.Bvsmodi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmodi</span></span></code></li><li id="type-bvarith.Bvnand" class="def variant constructor anchored"><a href="#type-bvarith.Bvnand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnand</span></span></code></li><li id="type-bvarith.Bvnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnor</span></span></code></li><li id="type-bvarith.Bvxnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxnor</span></span></code></li><li id="type-bvarith.Bvsub" class="def variant constructor anchored"><a href="#type-bvarith.Bvsub" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsub</span></span></code></li><li id="type-bvarith.Bvudiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudiv</span></span></code></li><li id="type-bvarith.Bvudivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudivi</span></span></code></li><li id="type-bvarith.Bvsdiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdiv</span></span></code></li><li id="type-bvarith.Bvsdivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdivi</span></span></code></li><li id="type-bvarith.Bvurem" class="def variant constructor anchored"><a href="#type-bvarith.Bvurem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvurem</span></span></code></li><li id="type-bvarith.Bvsrem" class="def variant constructor anchored"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsrem</span></span></code></li><li id="type-bvarith.Bvsmod" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmod</span></span></code></li><li id="type-bvarith.Bvshl" class="def variant constructor anchored"><a href="#type-bvarith.Bvshl" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvshl</span></span></code></li><li id="type-bvarith.Bvlshr" class="def variant constructor anchored"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvlshr</span></span></code></li><li id="type-bvarith.Bvashr" class="def variant constructor anchored"><a href="#type-bvarith.Bvashr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvashr</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span><span class="keyword">type</span> manyop</span><span> = <a href="../Ott/index.html#type-manyop">Ott.manyop</a></span><span> = </span></code><ol><li id="type-manyop.And" class="def variant constructor anchored"><a href="#type-manyop.And" class="anchor"></a><code><span>| </span><span><span class="constructor">And</span></span></code></li><li id="type-manyop.Or" class="def variant constructor anchored"><a href="#type-manyop.Or" class="anchor"></a><code><span>| </span><span><span class="constructor">Or</span></span></code></li><li id="type-manyop.Bvmanyarith" class="def variant constructor anchored"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="#type-bvmanyarith">bvmanyarith</a></span></code></li><li id="type-manyop.Concat" class="def variant constructor anchored"><a href="#type-manyop.Concat" class="anchor"></a><code><span>| </span><span><span class="constructor">Concat</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binop</span></span><span> = <span><span class="type-var">'m</span> <a href="../Ott/index.html#type-binop">Ott.binop</a></span></span><span> = </span></code><ol><li id="type-binop.Binmem" class="def variant constructor anchored"><a href="#type-binop.Binmem" class="anchor"></a><code><span>| </span><span><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binmem">binmem</a></span></span></code></li><li id="type-binop.Eq" class="def variant constructor anchored"><a href="#type-binop.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span></span></code></li><li id="type-binop.Bvarith" class="def variant constructor anchored"><a href="#type-binop.Bvarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="#type-bvarith">bvarith</a></span></code></li><li id="type-binop.Bvcomp" class="def variant constructor anchored"><a href="#type-binop.Bvcomp" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="#type-bvcomp">bvcomp</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span><span class="keyword">type</span> unop</span><span> = <a href="../Ott/index.html#type-unop">Ott.unop</a></span><span> = </span></code><ol><li id="type-unop.Not" class="def variant constructor anchored"><a href="#type-unop.Not" class="anchor"></a><code><span>| </span><span><span class="constructor">Not</span></span></code></li><li id="type-unop.Bvnot" class="def variant constructor anchored"><a href="#type-unop.Bvnot" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnot</span></span></code></li><li id="type-unop.Bvredand" class="def variant constructor anchored"><a href="#type-unop.Bvredand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredand</span></span></code></li><li id="type-unop.Bvredor" class="def variant constructor anchored"><a href="#type-unop.Bvredor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredor</span></span></code></li><li id="type-unop.Bvneg" class="def variant constructor anchored"><a href="#type-unop.Bvneg" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvneg</span></span></code></li><li id="type-unop.Extract" class="def variant constructor anchored"><a href="#type-unop.Extract" class="anchor"></a><code><span>| </span><span><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-unop.ZeroExtend" class="def variant constructor anchored"><a href="#type-unop.ZeroExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</span></code></li><li id="type-unop.SignExtend" class="def variant constructor anchored"><a href="#type-unop.SignExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span></span><span> = </span></code><ol><li id="type-exp.Var" class="def variant constructor anchored"><a href="#type-exp.Var" class="anchor"></a><code><span>| </span><span><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bound" class="def variant constructor anchored"><a href="#type-exp.Bound" class="anchor"></a><code><span>| </span><span><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bits" class="def variant constructor anchored"><a href="#type-exp.Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bool" class="def variant constructor anchored"><a href="#type-exp.Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></span></code></li><li id="type-exp.Enum" class="def variant constructor anchored"><a href="#type-exp.Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Unop" class="def variant constructor anchored"><a href="#type-exp.Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Binop" class="def variant constructor anchored"><a href="#type-exp.Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Manyop" class="def variant constructor anchored"><a href="#type-exp.Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Vec" class="def variant constructor anchored"><a href="#type-exp.Vec" class="anchor"></a><code><span>| </span><span><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Ite" class="def variant constructor anchored"><a href="#type-exp.Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Let" class="def variant constructor anchored"><a href="#type-exp.Let" class="anchor"></a><code><span>| </span><span><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>)</span> list</span>
+  * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m ty</span></span><span> = <span><span class="type-var">'m</span> <a href="../Ott/index.html#type-ty">Ott.ty</a></span></span><span> = </span></code><ol><li id="type-ty.Ty_Mem" class="def variant constructor anchored"><a href="#type-ty.Ty_Mem" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-ty.Ty_Bool" class="def variant constructor anchored"><a href="#type-ty.Ty_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Bool</span></span></code></li><li id="type-ty.Ty_BitVec" class="def variant constructor anchored"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Enum" class="def variant constructor anchored"><a href="#type-ty.Ty_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Array" class="def variant constructor anchored"><a href="#type-ty.Ty_Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span></span><span> = </span></code><ol><li id="type-smt.DeclareConst" class="def variant constructor anchored"><a href="#type-smt.DeclareConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li><li id="type-smt.DefineConst" class="def variant constructor anchored"><a href="#type-smt.DefineConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Assert" class="def variant constructor anchored"><a href="#type-smt.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Simplify" class="def variant constructor anchored"><a href="#type-smt.Simplify" class="anchor"></a><code><span>| </span><span><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></span></code></li><li id="type-smt.Push" class="def variant constructor anchored"><a href="#type-smt.Push" class="anchor"></a><code><span>| </span><span><span class="constructor">Push</span></span></code></li><li id="type-smt.Pop" class="def variant constructor anchored"><a href="#type-smt.Pop" class="anchor"></a><code><span>| </span><span><span class="constructor">Pop</span></span></code></li><li id="type-smt.GetVersion" class="def variant constructor anchored"><a href="#type-smt.GetVersion" class="anchor"></a><code><span>| </span><span><span class="constructor">GetVersion</span></span></code></li><li id="type-smt.CheckSat" class="def variant constructor anchored"><a href="#type-smt.CheckSat" class="anchor"></a><code><span>| </span><span><span class="constructor">CheckSat</span></span></code></li><li id="type-smt.Exit" class="def variant constructor anchored"><a href="#type-smt.Exit" class="anchor"></a><code><span>| </span><span><span class="constructor">Exit</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></span><span> = <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../Ott/index.html#type-smt_ans">Ott.smt_ans</a></span></span><span> = </span></code><ol><li id="type-smt_ans.Error" class="def variant constructor anchored"><a href="#type-smt_ans.Error" class="anchor"></a><code><span>| </span><span><span class="constructor">Error</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Version" class="def variant constructor anchored"><a href="#type-smt_ans.Version" class="anchor"></a><code><span>| </span><span><span class="constructor">Version</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Sat" class="def variant constructor anchored"><a href="#type-smt_ans.Sat" class="anchor"></a><code><span>| </span><span><span class="constructor">Sat</span></span></code></li><li id="type-smt_ans.Unsat" class="def variant constructor anchored"><a href="#type-smt_ans.Unsat" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsat</span></span></code></li><li id="type-smt_ans.Unknown" class="def variant constructor anchored"><a href="#type-smt_ans.Unknown" class="anchor"></a><code><span>| </span><span><span class="constructor">Unknown</span></span></code></li><li id="type-smt_ans.Unsupported" class="def variant constructor anchored"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsupported</span></span></code></li><li id="type-smt_ans.Exp" class="def variant constructor anchored"><a href="#type-smt_ans.Exp" class="anchor"></a><code><span>| </span><span><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li></ol></div></div><p>auxiliary functions on the new list types</p><p>library functions</p><p>subrules</p><p>auxiliary functions</p><p>free variables</p><p>substitutions</p><p>context application</p><p>definitions</p></details></div><div class="odoc-spec"><div class="spec type anchored" id="type-no"><a href="#type-no" class="anchor"></a><code><span><span class="keyword">type</span> no</span><span> = </span><span>|</span></code></div><div class="spec-doc"><p>Generic empty type. This kind of type is explained <a href="http://caml.inria.fr/pub/docs/manual-ocaml/emptyvariants.html">here</a>. In particular, when this type appear in a match case, the match case can contain a refutation pattern <code>.</code> to indicate that this impossible.</p><p>A refutation pattern also work with higher-level constructors, for example in this case:</p><pre class="language-ocaml"><code>type a = A of int | B of no * int
 let f : a -&gt; int = function
   | A i -&gt; i
-  | B _ -&gt; .</code></pre><p>It also work in product types:</p><pre><code class="ml">let f : no * int -&gt; unit = function _ -&gt; . </code></pre><p>However it doesn't work for sum types: the <code>no</code> type need to appear directly in the pattern:</p><pre><code class="ml">type complex_empty = A of no | B of no
+  | B _ -&gt; .</code></pre><p>It also work in product types:</p><pre class="language-ocaml"><code> let f : no * int -&gt; unit = function _ -&gt; . </code></pre><p>However it doesn't work for sum types: the <code>no</code> type need to appear directly in the pattern:</p><pre class="language-ocaml"><code>type complex_empty = A of no | B of no
 let f : complex_empty = function _ -&gt; . (* does not compile *)
-let f : complex_empty = function A _ | B _ -&gt; . (* compiles *)</code></pre><p>In case this behavior is needed, there <a href="../../Ast/index.html#destr"><span>Destructors</span></a> in <a href="../../Ast/index.html"><code>Ast</code></a>. See this section to see how they are used.</p></dd></dl><dl><dt class="spec type" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span class="keyword">type</span> loc</code><code> = Stdlib.Lexing.position</code></dt><dd><p><a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Lexing.html#TYPEposition"><code>Lexing.position</code></a></p></dd></dl><dl><dt class="spec type" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span class="keyword">type</span> lrng</code><code> = Isla_lang.AST.lrng</code></dt><dd><p>The type of an expression range. This imported from Isla to avoid having two incompatible types.</p><p>This represent a range in a source file, so generally this is a pair of <a href="index.html#type-loc"><code>loc</code></a>, but it may also be <code>Unknown</code>.</p></dd></dl><div class="spec module" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span class="keyword">module</span> <a href="Size/index.html">Size</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span class="keyword">type</span> rexp</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-exp">exp</a></span></code></dt><dd><p>Raw expression coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rty"><a href="#type-rty" class="anchor"></a><code><span class="keyword">type</span> rty</code><code> = <span><a href="Size/index.html#type-t">Size.t</a> <a href="index.html#type-ty">ty</a></span></code></dt><dd><p>Raw type coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span class="keyword">type</span> rsmt</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-smt">smt</a></span></code></dt><dd><p>Raw SMT command coming out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt_ans"><a href="#type-rsmt_ans" class="anchor"></a><code><span class="keyword">type</span> rsmt_ans</code><code> = <span><span>(<a href="index.html#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="index.html#type-smt_ans">smt_ans</a></span></code></dt><dd><p>Raw SMT answer coming out of the parser</p></dd></dl></div></body></html>
\ No newline at end of file
+let f : complex_empty = function A _ | B _ -&gt; . (* compiles *)</code></pre><p>In case this behavior is needed, there <a href="../../Ast/index.html#destr" title="destr">Destructors</a> in <a href="../../Ast/index.html"><code>Ast</code></a>. See this section to see how they are used.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span><span class="keyword">type</span> loc</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></div><div class="spec-doc"><p><a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Lexing.html#TYPEposition"><code>Lexing.position</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span><span class="keyword">type</span> lrng</span><span> = <span class="xref-unresolved">Isla_lang</span>.AST.lrng</span></code></div><div class="spec-doc"><p>The type of an expression range. This imported from Isla to avoid having two incompatible types.</p><p>This represent a range in a source file, so generally this is a pair of <a href="#type-loc"><code>loc</code></a>, but it may also be <code>Unknown</code>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Size/index.html">Size</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span><span class="keyword">type</span> rexp</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="#type-exp">exp</a></span></span></code></div><div class="spec-doc"><p>Raw expression coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rty"><a href="#type-rty" class="anchor"></a><code><span><span class="keyword">type</span> rty</span><span> = <span><a href="Size/index.html#type-t">Size.t</a> <a href="#type-ty">ty</a></span></span></code></div><div class="spec-doc"><p>Raw type coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span><span class="keyword">type</span> rsmt</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="#type-smt">smt</a></span></span></code></div><div class="spec-doc"><p>Raw SMT command coming out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt_ans"><a href="#type-rsmt_ans" class="anchor"></a><code><span><span class="keyword">type</span> rsmt_ans</span><span> = <span><span>(<a href="#type-lrng">lrng</a>, string, string, <a href="Size/index.html#type-t">Size.t</a>)</span> <a href="#type-smt_ans">smt_ans</a></span></span></code></div><div class="spec-doc"><p>Raw SMT answer coming out of the parser</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/Lexer/index.html b/doc/html/read-dwarf/AstGen/Lexer/index.html
index 6f7fb60d..f03e70e6 100644
--- a/doc/html/read-dwarf/AstGen/Lexer/index.html
+++ b/doc/html/read-dwarf/AstGen/Lexer/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lexer (read-dwarf.AstGen.Lexer)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Lexer</nav><h1>Module <code>AstGen.Lexer</code></h1></header><dl><dt class="spec exception" id="exception-Error"><a href="#exception-Error" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Error</span> <span class="keyword">of</span> string</code></dt></dl><dl><dt class="spec value" id="val-__ocaml_lex_tables"><a href="#val-__ocaml_lex_tables" class="anchor"></a><code><span class="keyword">val</span> __ocaml_lex_tables : Stdlib.Lexing.lex_tables</code></dt><dt class="spec value" id="val-token"><a href="#val-token" class="anchor"></a><code><span class="keyword">val</span> token : Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="../Parser/index.html#type-token">Parser.token</a></code></dt><dt class="spec value" id="val-__ocaml_lex_token_rec"><a href="#val-__ocaml_lex_token_rec" class="anchor"></a><code><span class="keyword">val</span> __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../Parser/index.html#type-token">Parser.token</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lexer (read-dwarf.AstGen.Lexer)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Lexer</nav><header class="odoc-preamble"><h1>Module <code><span>AstGen.Lexer</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec exception anchored" id="exception-Error"><a href="#exception-Error" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Error</span> <span class="keyword">of</span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-__ocaml_lex_tables"><a href="#val-__ocaml_lex_tables" class="anchor"></a><code><span><span class="keyword">val</span> __ocaml_lex_tables : <span class="xref-unresolved">Stdlib</span>.Lexing.lex_tables</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-token"><a href="#val-token" class="anchor"></a><code><span><span class="keyword">val</span> token : <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="../Parser/index.html#type-token">Parser.token</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-__ocaml_lex_token_rec"><a href="#val-__ocaml_lex_token_rec" class="anchor"></a><code><span><span class="keyword">val</span> __ocaml_lex_token_rec : <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../Parser/index.html#type-token">Parser.token</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/Ott/index.html b/doc/html/read-dwarf/AstGen/Ott/index.html
index f1d379eb..a157493d 100644
--- a/doc/html/read-dwarf/AstGen/Ott/index.html
+++ b/doc/html/read-dwarf/AstGen/Ott/index.html
@@ -1,2 +1,5 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Ott (read-dwarf.AstGen.Ott)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Ott</nav><h1>Module <code>AstGen.Ott</code></h1></header><aside><p>warning: the backend selected ignores the file structure informations</p></aside><dl><dt class="spec type" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span class="keyword">type</span> bvar</code><code> = string</code></dt><dd><p>syntax</p></dd></dl><dl><dt class="spec type" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span class="keyword">type</span> flag</code><code> = string</code></dt><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = int * int</code></dt><dt class="spec type" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span class="keyword">type</span> <span>'m binmem</span></code><code> = </code><table class="variant"><tr id="type-binmem.Select" class="anchored"><td class="def constructor"><a href="#type-binmem.Select" class="anchor"></a><code>| </code><code><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-binmem.Store" class="anchored"><td class="def constructor"><a href="#type-binmem.Store" class="anchor"></a><code>| </code><code><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr></table></dt><dt class="spec type" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span class="keyword">type</span> bvarith</code><code> = </code><table class="variant"><tr id="type-bvarith.Bvuremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvuremi</span></code></td></tr><tr id="type-bvarith.Bvsremi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsremi</span></code></td></tr><tr id="type-bvarith.Bvsmodi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmodi</span></code></td></tr><tr id="type-bvarith.Bvnand" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnand" class="anchor"></a><code>| </code><code><span class="constructor">Bvnand</span></code></td></tr><tr id="type-bvarith.Bvnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvnor</span></code></td></tr><tr id="type-bvarith.Bvxnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxnor</span></code></td></tr><tr id="type-bvarith.Bvsub" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsub" class="anchor"></a><code>| </code><code><span class="constructor">Bvsub</span></code></td></tr><tr id="type-bvarith.Bvudiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvudiv</span></code></td></tr><tr id="type-bvarith.Bvudivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvudivi</span></code></td></tr><tr id="type-bvarith.Bvsdiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdiv</span></code></td></tr><tr id="type-bvarith.Bvsdivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdivi</span></code></td></tr><tr id="type-bvarith.Bvurem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvurem" class="anchor"></a><code>| </code><code><span class="constructor">Bvurem</span></code></td></tr><tr id="type-bvarith.Bvsrem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code>| </code><code><span class="constructor">Bvsrem</span></code></td></tr><tr id="type-bvarith.Bvsmod" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmod</span></code></td></tr><tr id="type-bvarith.Bvshl" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvshl" class="anchor"></a><code>| </code><code><span class="constructor">Bvshl</span></code></td></tr><tr id="type-bvarith.Bvlshr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code>| </code><code><span class="constructor">Bvlshr</span></code></td></tr><tr id="type-bvarith.Bvashr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvashr" class="anchor"></a><code>| </code><code><span class="constructor">Bvashr</span></code></td></tr></table></dt><dt class="spec type" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span class="keyword">type</span> bvcomp</code><code> = </code><table class="variant"><tr id="type-bvcomp.Bvult" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvult" class="anchor"></a><code>| </code><code><span class="constructor">Bvult</span></code></td></tr><tr id="type-bvcomp.Bvslt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code>| </code><code><span class="constructor">Bvslt</span></code></td></tr><tr id="type-bvcomp.Bvule" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvule" class="anchor"></a><code>| </code><code><span class="constructor">Bvule</span></code></td></tr><tr id="type-bvcomp.Bvsle" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code>| </code><code><span class="constructor">Bvsle</span></code></td></tr><tr id="type-bvcomp.Bvuge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code>| </code><code><span class="constructor">Bvuge</span></code></td></tr><tr id="type-bvcomp.Bvsge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code>| </code><code><span class="constructor">Bvsge</span></code></td></tr><tr id="type-bvcomp.Bvugt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code>| </code><code><span class="constructor">Bvugt</span></code></td></tr><tr id="type-bvcomp.Bvsgt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code>| </code><code><span class="constructor">Bvsgt</span></code></td></tr></table></dt><dt class="spec type" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span class="keyword">type</span> bvmanyarith</code><code> = </code><table class="variant"><tr id="type-bvmanyarith.Bvand" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code>| </code><code><span class="constructor">Bvand</span></code></td></tr><tr id="type-bvmanyarith.Bvor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code>| </code><code><span class="constructor">Bvor</span></code></td></tr><tr id="type-bvmanyarith.Bvxor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxor</span></code></td></tr><tr id="type-bvmanyarith.Bvadd" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code>| </code><code><span class="constructor">Bvadd</span></code></td></tr><tr id="type-bvmanyarith.Bvmul" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code>| </code><code><span class="constructor">Bvmul</span></code></td></tr></table></dt><dt class="spec type" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span class="keyword">type</span> unop</code><code> = </code><table class="variant"><tr id="type-unop.Not" class="anchored"><td class="def constructor"><a href="#type-unop.Not" class="anchor"></a><code>| </code><code><span class="constructor">Not</span></code></td></tr><tr id="type-unop.Bvnot" class="anchored"><td class="def constructor"><a href="#type-unop.Bvnot" class="anchor"></a><code>| </code><code><span class="constructor">Bvnot</span></code></td></tr><tr id="type-unop.Bvredand" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredand" class="anchor"></a><code>| </code><code><span class="constructor">Bvredand</span></code></td></tr><tr id="type-unop.Bvredor" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredor" class="anchor"></a><code>| </code><code><span class="constructor">Bvredor</span></code></td></tr><tr id="type-unop.Bvneg" class="anchored"><td class="def constructor"><a href="#type-unop.Bvneg" class="anchor"></a><code>| </code><code><span class="constructor">Bvneg</span></code></td></tr><tr id="type-unop.Extract" class="anchored"><td class="def constructor"><a href="#type-unop.Extract" class="anchor"></a><code>| </code><code><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-unop.ZeroExtend" class="anchored"><td class="def constructor"><a href="#type-unop.ZeroExtend" class="anchor"></a><code>| </code><code><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-unop.SignExtend" class="anchored"><td class="def constructor"><a href="#type-unop.SignExtend" class="anchor"></a><code>| </code><code><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span class="keyword">type</span> <span>'m binop</span></code><code> = </code><table class="variant"><tr id="type-binop.Binmem" class="anchored"><td class="def constructor"><a href="#type-binop.Binmem" class="anchor"></a><code>| </code><code><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binmem">binmem</a></span></code></td></tr><tr id="type-binop.Eq" class="anchored"><td class="def constructor"><a href="#type-binop.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span></code></td></tr><tr id="type-binop.Bvarith" class="anchored"><td class="def constructor"><a href="#type-binop.Bvarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="index.html#type-bvarith">bvarith</a></code></td></tr><tr id="type-binop.Bvcomp" class="anchored"><td class="def constructor"><a href="#type-binop.Bvcomp" class="anchor"></a><code>| </code><code><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="index.html#type-bvcomp">bvcomp</a></code></td></tr></table></dt><dt class="spec type" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span class="keyword">type</span> manyop</code><code> = </code><table class="variant"><tr id="type-manyop.And" class="anchored"><td class="def constructor"><a href="#type-manyop.And" class="anchor"></a><code>| </code><code><span class="constructor">And</span></code></td></tr><tr id="type-manyop.Or" class="anchored"><td class="def constructor"><a href="#type-manyop.Or" class="anchor"></a><code>| </code><code><span class="constructor">Or</span></code></td></tr><tr id="type-manyop.Bvmanyarith" class="anchored"><td class="def constructor"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="index.html#type-bvmanyarith">bvmanyarith</a></code></td></tr><tr id="type-manyop.Concat" class="anchored"><td class="def constructor"><a href="#type-manyop.Concat" class="anchor"></a><code>| </code><code><span class="constructor">Concat</span></code></td></tr></table></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></code><code> = </code><table class="variant"><tr id="type-exp.Var" class="anchored"><td class="def constructor"><a href="#type-exp.Var" class="anchor"></a><code>| </code><code><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bound" class="anchored"><td class="def constructor"><a href="#type-exp.Bound" class="anchor"></a><code>| </code><code><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bits" class="anchored"><td class="def constructor"><a href="#type-exp.Bits" class="anchor"></a><code>| </code><code><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bool" class="anchored"><td class="def constructor"><a href="#type-exp.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Enum" class="anchored"><td class="def constructor"><a href="#type-exp.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Unop" class="anchored"><td class="def constructor"><a href="#type-exp.Unop" class="anchor"></a><code>| </code><code><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Binop" class="anchored"><td class="def constructor"><a href="#type-exp.Binop" class="anchor"></a><code>| </code><code><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Manyop" class="anchored"><td class="def constructor"><a href="#type-exp.Manyop" class="anchor"></a><code>| </code><code><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Vec" class="anchored"><td class="def constructor"><a href="#type-exp.Vec" class="anchor"></a><code>| </code><code><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Ite" class="anchored"><td class="def constructor"><a href="#type-exp.Ite" class="anchor"></a><code>| </code><code><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Let" class="anchored"><td class="def constructor"><a href="#type-exp.Let" class="anchor"></a><code>| </code><code><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span>)</span> list</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> <span>'m ty</span></code><code> = </code><table class="variant"><tr id="type-ty.Ty_Mem" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Mem" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></code></td></tr><tr id="type-ty.Ty_Bool" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Bool</span></code></td></tr><tr id="type-ty.Ty_BitVec" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code>| </code><code><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Enum" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Array" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Array" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr></table></dt><dt class="spec type" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></code><code> = </code><table class="variant"><tr id="type-smt.DeclareConst" class="anchored"><td class="def constructor"><a href="#type-smt.DeclareConst" class="anchor"></a><code>| </code><code><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="index.html#type-ty">ty</a></span></code></td></tr><tr id="type-smt.DefineConst" class="anchored"><td class="def constructor"><a href="#type-smt.DefineConst" class="anchor"></a><code>| </code><code><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Assert" class="anchored"><td class="def constructor"><a href="#type-smt.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Simplify" class="anchored"><td class="def constructor"><a href="#type-smt.Simplify" class="anchor"></a><code>| </code><code><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></code></td></tr><tr id="type-smt.Push" class="anchored"><td class="def constructor"><a href="#type-smt.Push" class="anchor"></a><code>| </code><code><span class="constructor">Push</span></code></td></tr><tr id="type-smt.Pop" class="anchored"><td class="def constructor"><a href="#type-smt.Pop" class="anchor"></a><code>| </code><code><span class="constructor">Pop</span></code></td></tr><tr id="type-smt.GetVersion" class="anchored"><td class="def constructor"><a href="#type-smt.GetVersion" class="anchor"></a><code>| </code><code><span class="constructor">GetVersion</span></code></td></tr><tr id="type-smt.CheckSat" class="anchored"><td class="def constructor"><a href="#type-smt.CheckSat" class="anchor"></a><code>| </code><code><span class="constructor">CheckSat</span></code></td></tr><tr id="type-smt.Exit" class="anchored"><td class="def constructor"><a href="#type-smt.Exit" class="anchor"></a><code>| </code><code><span class="constructor">Exit</span></code></td></tr></table></dt><dt class="spec type" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></code><code> = </code><table class="variant"><tr id="type-smt_ans.Error" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Error" class="anchor"></a><code>| </code><code><span class="constructor">Error</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Version" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Version" class="anchor"></a><code>| </code><code><span class="constructor">Version</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-smt_ans.Sat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Sat" class="anchor"></a><code>| </code><code><span class="constructor">Sat</span></code></td></tr><tr id="type-smt_ans.Unsat" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsat" class="anchor"></a><code>| </code><code><span class="constructor">Unsat</span></code></td></tr><tr id="type-smt_ans.Unknown" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unknown" class="anchor"></a><code>| </code><code><span class="constructor">Unknown</span></code></td></tr><tr id="type-smt_ans.Unsupported" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code>| </code><code><span class="constructor">Unsupported</span></code></td></tr><tr id="type-smt_ans.Exp" class="anchored"><td class="def constructor"><a href="#type-smt_ans.Exp" class="anchor"></a><code>| </code><code><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span></code></td></tr></table></dt></dl><aside><p>auxiliary functions on the new list types</p></aside><aside><p>library functions</p></aside><aside><p>subrules</p></aside><aside><p>auxiliary functions</p></aside><aside><p>free variables</p></aside><aside><p>substitutions</p></aside><aside><p>context application</p></aside><aside><p>definitions</p></aside></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Ott (read-dwarf.AstGen.Ott)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Ott</nav><header class="odoc-preamble"><h1>Module <code><span>AstGen.Ott</span></code></h1><p>warning: the backend selected ignores the file structure informations</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-bvar"><a href="#type-bvar" class="anchor"></a><code><span><span class="keyword">type</span> bvar</span><span> = string</span></code></div><div class="spec-doc"><p>syntax</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-flag"><a href="#type-flag" class="anchor"></a><code><span><span class="keyword">type</span> flag</span><span> = string</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span><span class="keyword">type</span> bvmanyarith</span><span> = </span></code><ol><li id="type-bvmanyarith.Bvand" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvand</span></span></code></li><li id="type-bvmanyarith.Bvor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvor</span></span></code></li><li id="type-bvmanyarith.Bvxor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxor</span></span></code></li><li id="type-bvmanyarith.Bvadd" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvadd</span></span></code></li><li id="type-bvmanyarith.Bvmul" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmul</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binmem"><a href="#type-binmem" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binmem</span></span><span> = </span></code><ol><li id="type-binmem.Select" class="def variant constructor anchored"><a href="#type-binmem.Select" class="anchor"></a><code><span>| </span><span><span class="constructor">Select</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-binmem.Store" class="def variant constructor anchored"><a href="#type-binmem.Store" class="anchor"></a><code><span>| </span><span><span class="constructor">Store</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span><span class="keyword">type</span> bvcomp</span><span> = </span></code><ol><li id="type-bvcomp.Bvult" class="def variant constructor anchored"><a href="#type-bvcomp.Bvult" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvult</span></span></code></li><li id="type-bvcomp.Bvslt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvslt</span></span></code></li><li id="type-bvcomp.Bvule" class="def variant constructor anchored"><a href="#type-bvcomp.Bvule" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvule</span></span></code></li><li id="type-bvcomp.Bvsle" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsle</span></span></code></li><li id="type-bvcomp.Bvuge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuge</span></span></code></li><li id="type-bvcomp.Bvsge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsge</span></span></code></li><li id="type-bvcomp.Bvugt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvugt</span></span></code></li><li id="type-bvcomp.Bvsgt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsgt</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span><span class="keyword">type</span> bvarith</span><span> = </span></code><ol><li id="type-bvarith.Bvuremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvuremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuremi</span></span></code></li><li id="type-bvarith.Bvsremi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsremi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsremi</span></span></code></li><li id="type-bvarith.Bvsmodi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmodi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmodi</span></span></code></li><li id="type-bvarith.Bvnand" class="def variant constructor anchored"><a href="#type-bvarith.Bvnand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnand</span></span></code></li><li id="type-bvarith.Bvnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnor</span></span></code></li><li id="type-bvarith.Bvxnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxnor</span></span></code></li><li id="type-bvarith.Bvsub" class="def variant constructor anchored"><a href="#type-bvarith.Bvsub" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsub</span></span></code></li><li id="type-bvarith.Bvudiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudiv</span></span></code></li><li id="type-bvarith.Bvudivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudivi</span></span></code></li><li id="type-bvarith.Bvsdiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdiv</span></span></code></li><li id="type-bvarith.Bvsdivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdivi</span></span></code></li><li id="type-bvarith.Bvurem" class="def variant constructor anchored"><a href="#type-bvarith.Bvurem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvurem</span></span></code></li><li id="type-bvarith.Bvsrem" class="def variant constructor anchored"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsrem</span></span></code></li><li id="type-bvarith.Bvsmod" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmod</span></span></code></li><li id="type-bvarith.Bvshl" class="def variant constructor anchored"><a href="#type-bvarith.Bvshl" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvshl</span></span></code></li><li id="type-bvarith.Bvlshr" class="def variant constructor anchored"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvlshr</span></span></code></li><li id="type-bvarith.Bvashr" class="def variant constructor anchored"><a href="#type-bvarith.Bvashr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvashr</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span><span class="keyword">type</span> manyop</span><span> = </span></code><ol><li id="type-manyop.And" class="def variant constructor anchored"><a href="#type-manyop.And" class="anchor"></a><code><span>| </span><span><span class="constructor">And</span></span></code></li><li id="type-manyop.Or" class="def variant constructor anchored"><a href="#type-manyop.Or" class="anchor"></a><code><span>| </span><span><span class="constructor">Or</span></span></code></li><li id="type-manyop.Bvmanyarith" class="def variant constructor anchored"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="#type-bvmanyarith">bvmanyarith</a></span></code></li><li id="type-manyop.Concat" class="def variant constructor anchored"><a href="#type-manyop.Concat" class="anchor"></a><code><span>| </span><span><span class="constructor">Concat</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m binop</span></span><span> = </span></code><ol><li id="type-binop.Binmem" class="def variant constructor anchored"><a href="#type-binop.Binmem" class="anchor"></a><code><span>| </span><span><span class="constructor">Binmem</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binmem">binmem</a></span></span></code></li><li id="type-binop.Eq" class="def variant constructor anchored"><a href="#type-binop.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span></span></code></li><li id="type-binop.Bvarith" class="def variant constructor anchored"><a href="#type-binop.Bvarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="#type-bvarith">bvarith</a></span></code></li><li id="type-binop.Bvcomp" class="def variant constructor anchored"><a href="#type-binop.Bvcomp" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="#type-bvcomp">bvcomp</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span><span class="keyword">type</span> unop</span><span> = </span></code><ol><li id="type-unop.Not" class="def variant constructor anchored"><a href="#type-unop.Not" class="anchor"></a><code><span>| </span><span><span class="constructor">Not</span></span></code></li><li id="type-unop.Bvnot" class="def variant constructor anchored"><a href="#type-unop.Bvnot" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnot</span></span></code></li><li id="type-unop.Bvredand" class="def variant constructor anchored"><a href="#type-unop.Bvredand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredand</span></span></code></li><li id="type-unop.Bvredor" class="def variant constructor anchored"><a href="#type-unop.Bvredor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredor</span></span></code></li><li id="type-unop.Bvneg" class="def variant constructor anchored"><a href="#type-unop.Bvneg" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvneg</span></span></code></li><li id="type-unop.Extract" class="def variant constructor anchored"><a href="#type-unop.Extract" class="anchor"></a><code><span>| </span><span><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-unop.ZeroExtend" class="def variant constructor anchored"><a href="#type-unop.ZeroExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</span></code></li><li id="type-unop.SignExtend" class="def variant constructor anchored"><a href="#type-unop.SignExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) exp</span></span><span> = </span></code><ol><li id="type-exp.Var" class="def variant constructor anchored"><a href="#type-exp.Var" class="anchor"></a><code><span>| </span><span><span class="constructor">Var</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bound" class="def variant constructor anchored"><a href="#type-exp.Bound" class="anchor"></a><code><span>| </span><span><span class="constructor">Bound</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bits" class="def variant constructor anchored"><a href="#type-exp.Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Bits</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Bool" class="def variant constructor anchored"><a href="#type-exp.Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></span></code></li><li id="type-exp.Enum" class="def variant constructor anchored"><a href="#type-exp.Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Unop" class="def variant constructor anchored"><a href="#type-exp.Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Binop" class="def variant constructor anchored"><a href="#type-exp.Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">Binop</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-binop">binop</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Manyop" class="def variant constructor anchored"><a href="#type-exp.Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Vec" class="def variant constructor anchored"><a href="#type-exp.Vec" class="anchor"></a><code><span>| </span><span><span class="constructor">Vec</span> <span class="keyword">of</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Ite" class="def variant constructor anchored"><a href="#type-exp.Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Let" class="def variant constructor anchored"><a href="#type-exp.Let" class="anchor"></a><code><span>| </span><span><span class="constructor">Let</span> <span class="keyword">of</span> <span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span><span>(<span class="type-var">'b</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>)</span> list</span>
+  * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span>
+  * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> <span>'m ty</span></span><span> = </span></code><ol><li id="type-ty.Ty_Mem" class="def variant constructor anchored"><a href="#type-ty.Ty_Mem" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Mem</span> <span class="keyword">of</span> <span class="type-var">'m</span></span></code></li><li id="type-ty.Ty_Bool" class="def variant constructor anchored"><a href="#type-ty.Ty_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Bool</span></span></code></li><li id="type-ty.Ty_BitVec" class="def variant constructor anchored"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Enum" class="def variant constructor anchored"><a href="#type-ty.Ty_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Array" class="def variant constructor anchored"><a href="#type-ty.Ty_Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt</span></span><span> = </span></code><ol><li id="type-smt.DeclareConst" class="def variant constructor anchored"><a href="#type-smt.DeclareConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DeclareConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span class="type-var">'m</span> <a href="#type-ty">ty</a></span></span></code></li><li id="type-smt.DefineConst" class="def variant constructor anchored"><a href="#type-smt.DefineConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineConst</span> <span class="keyword">of</span> <span class="type-var">'v</span> * <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Assert" class="def variant constructor anchored"><a href="#type-smt.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Simplify" class="def variant constructor anchored"><a href="#type-smt.Simplify" class="anchor"></a><code><span>| </span><span><span class="constructor">Simplify</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> * <span><span>(string * bool)</span> list</span></span></code></li><li id="type-smt.Push" class="def variant constructor anchored"><a href="#type-smt.Push" class="anchor"></a><code><span>| </span><span><span class="constructor">Push</span></span></code></li><li id="type-smt.Pop" class="def variant constructor anchored"><a href="#type-smt.Pop" class="anchor"></a><code><span>| </span><span><span class="constructor">Pop</span></span></code></li><li id="type-smt.GetVersion" class="def variant constructor anchored"><a href="#type-smt.GetVersion" class="anchor"></a><code><span>| </span><span><span class="constructor">GetVersion</span></span></code></li><li id="type-smt.CheckSat" class="def variant constructor anchored"><a href="#type-smt.CheckSat" class="anchor"></a><code><span>| </span><span><span class="constructor">CheckSat</span></span></code></li><li id="type-smt.Exit" class="def variant constructor anchored"><a href="#type-smt.Exit" class="anchor"></a><code><span>| </span><span><span class="constructor">Exit</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt_ans"><a href="#type-smt_ans" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'v, 'b, 'm) smt_ans</span></span><span> = </span></code><ol><li id="type-smt_ans.Error" class="def variant constructor anchored"><a href="#type-smt_ans.Error" class="anchor"></a><code><span>| </span><span><span class="constructor">Error</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Version" class="def variant constructor anchored"><a href="#type-smt_ans.Version" class="anchor"></a><code><span>| </span><span><span class="constructor">Version</span> <span class="keyword">of</span> string</span></code></li><li id="type-smt_ans.Sat" class="def variant constructor anchored"><a href="#type-smt_ans.Sat" class="anchor"></a><code><span>| </span><span><span class="constructor">Sat</span></span></code></li><li id="type-smt_ans.Unsat" class="def variant constructor anchored"><a href="#type-smt_ans.Unsat" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsat</span></span></code></li><li id="type-smt_ans.Unknown" class="def variant constructor anchored"><a href="#type-smt_ans.Unknown" class="anchor"></a><code><span>| </span><span><span class="constructor">Unknown</span></span></code></li><li id="type-smt_ans.Unsupported" class="def variant constructor anchored"><a href="#type-smt_ans.Unsupported" class="anchor"></a><code><span>| </span><span><span class="constructor">Unsupported</span></span></code></li><li id="type-smt_ans.Exp" class="def variant constructor anchored"><a href="#type-smt_ans.Exp" class="anchor"></a><code><span>| </span><span><span class="constructor">Exp</span> <span class="keyword">of</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span></span></code></li></ol></div></div><p>auxiliary functions on the new list types</p><p>library functions</p><p>subrules</p><p>auxiliary functions</p><p>free variables</p><p>substitutions</p><p>context application</p><p>definitions</p></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/Parser/index.html b/doc/html/read-dwarf/AstGen/Parser/index.html
index b69b033f..59c28654 100644
--- a/doc/html/read-dwarf/AstGen/Parser/index.html
+++ b/doc/html/read-dwarf/AstGen/Parser/index.html
@@ -1,2 +1,14 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Parser (read-dwarf.AstGen.Parser)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Parser</nav><h1>Module <code>AstGen.Parser</code></h1></header><dl><dt class="spec type" id="type-token"><a href="#type-token" class="anchor"></a><code><span class="keyword">type</span> token</code><code> = </code><table class="variant"><tr id="type-token.ZERO_UNDERSCORE_EXTEND" class="anchored"><td class="def constructor"><a href="#type-token.ZERO_UNDERSCORE_EXTEND" class="anchor"></a><code>| </code><code><span class="constructor">ZERO_UNDERSCORE_EXTEND</span></code></td></tr><tr id="type-token.VVAR" class="anchored"><td class="def constructor"><a href="#type-token.VVAR" class="anchor"></a><code>| </code><code><span class="constructor">VVAR</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-token.UNSUPPORTED" class="anchored"><td class="def constructor"><a href="#type-token.UNSUPPORTED" class="anchor"></a><code>| </code><code><span class="constructor">UNSUPPORTED</span></code></td></tr><tr id="type-token.UNSAT" class="anchored"><td class="def constructor"><a href="#type-token.UNSAT" class="anchor"></a><code>| </code><code><span class="constructor">UNSAT</span></code></td></tr><tr id="type-token.UNKNOWN" class="anchored"><td class="def constructor"><a href="#type-token.UNKNOWN" class="anchor"></a><code>| </code><code><span class="constructor">UNKNOWN</span></code></td></tr><tr id="type-token.TRUE" class="anchored"><td class="def constructor"><a href="#type-token.TRUE" class="anchor"></a><code>| </code><code><span class="constructor">TRUE</span></code></td></tr><tr id="type-token.STR" class="anchored"><td class="def constructor"><a href="#type-token.STR" class="anchor"></a><code>| </code><code><span class="constructor">STR</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-token.STORE" class="anchored"><td class="def constructor"><a href="#type-token.STORE" class="anchor"></a><code>| </code><code><span class="constructor">STORE</span></code></td></tr><tr id="type-token.SIMPLIFY" class="anchored"><td class="def constructor"><a href="#type-token.SIMPLIFY" class="anchor"></a><code>| </code><code><span class="constructor">SIMPLIFY</span></code></td></tr><tr id="type-token.SIGN_UNDERSCORE_EXTEND" class="anchored"><td class="def constructor"><a href="#type-token.SIGN_UNDERSCORE_EXTEND" class="anchor"></a><code>| </code><code><span class="constructor">SIGN_UNDERSCORE_EXTEND</span></code></td></tr><tr id="type-token.SELECT" class="anchored"><td class="def constructor"><a href="#type-token.SELECT" class="anchor"></a><code>| </code><code><span class="constructor">SELECT</span></code></td></tr><tr id="type-token.SAT" class="anchored"><td class="def constructor"><a href="#type-token.SAT" class="anchor"></a><code>| </code><code><span class="constructor">SAT</span></code></td></tr><tr id="type-token.RPAREN" class="anchored"><td class="def constructor"><a href="#type-token.RPAREN" class="anchor"></a><code>| </code><code><span class="constructor">RPAREN</span></code></td></tr><tr id="type-token.PUSH" class="anchored"><td class="def constructor"><a href="#type-token.PUSH" class="anchor"></a><code>| </code><code><span class="constructor">PUSH</span></code></td></tr><tr id="type-token.POP" class="anchored"><td class="def constructor"><a href="#type-token.POP" class="anchor"></a><code>| </code><code><span class="constructor">POP</span></code></td></tr><tr id="type-token.OR" class="anchored"><td class="def constructor"><a href="#type-token.OR" class="anchor"></a><code>| </code><code><span class="constructor">OR</span></code></td></tr><tr id="type-token.NOT" class="anchored"><td class="def constructor"><a href="#type-token.NOT" class="anchor"></a><code>| </code><code><span class="constructor">NOT</span></code></td></tr><tr id="type-token.NAME" class="anchored"><td class="def constructor"><a href="#type-token.NAME" class="anchor"></a><code>| </code><code><span class="constructor">NAME</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-token.MEM" class="anchored"><td class="def constructor"><a href="#type-token.MEM" class="anchor"></a><code>| </code><code><span class="constructor">MEM</span></code></td></tr><tr id="type-token.LPAREN_UNDERSCORE" class="anchored"><td class="def constructor"><a href="#type-token.LPAREN_UNDERSCORE" class="anchor"></a><code>| </code><code><span class="constructor">LPAREN_UNDERSCORE</span></code></td></tr><tr id="type-token.LPAREN" class="anchored"><td class="def constructor"><a href="#type-token.LPAREN" class="anchor"></a><code>| </code><code><span class="constructor">LPAREN</span></code></td></tr><tr id="type-token.LET" class="anchored"><td class="def constructor"><a href="#type-token.LET" class="anchor"></a><code>| </code><code><span class="constructor">LET</span></code></td></tr><tr id="type-token.ITE" class="anchored"><td class="def constructor"><a href="#type-token.ITE" class="anchor"></a><code>| </code><code><span class="constructor">ITE</span></code></td></tr><tr id="type-token.INT" class="anchored"><td class="def constructor"><a href="#type-token.INT" class="anchor"></a><code>| </code><code><span class="constructor">INT</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-token.GET_MINUS_INFO" class="anchored"><td class="def constructor"><a href="#type-token.GET_MINUS_INFO" class="anchor"></a><code>| </code><code><span class="constructor">GET_MINUS_INFO</span></code></td></tr><tr id="type-token.FLAG" class="anchored"><td class="def constructor"><a href="#type-token.FLAG" class="anchor"></a><code>| </code><code><span class="constructor">FLAG</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-token.FALSE" class="anchored"><td class="def constructor"><a href="#type-token.FALSE" class="anchor"></a><code>| </code><code><span class="constructor">FALSE</span></code></td></tr><tr id="type-token.EXTRACT" class="anchored"><td class="def constructor"><a href="#type-token.EXTRACT" class="anchor"></a><code>| </code><code><span class="constructor">EXTRACT</span></code></td></tr><tr id="type-token.EXIT" class="anchored"><td class="def constructor"><a href="#type-token.EXIT" class="anchor"></a><code>| </code><code><span class="constructor">EXIT</span></code></td></tr><tr id="type-token.ERROR" class="anchored"><td class="def constructor"><a href="#type-token.ERROR" class="anchor"></a><code>| </code><code><span class="constructor">ERROR</span></code></td></tr><tr id="type-token.EQ" class="anchored"><td class="def constructor"><a href="#type-token.EQ" class="anchor"></a><code>| </code><code><span class="constructor">EQ</span></code></td></tr><tr id="type-token.EOF" class="anchored"><td class="def constructor"><a href="#type-token.EOF" class="anchor"></a><code>| </code><code><span class="constructor">EOF</span></code></td></tr><tr id="type-token.ENUM_UNDERSCORE_TY" class="anchored"><td class="def constructor"><a href="#type-token.ENUM_UNDERSCORE_TY" class="anchor"></a><code>| </code><code><span class="constructor">ENUM_UNDERSCORE_TY</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-token.ENUM" class="anchored"><td class="def constructor"><a href="#type-token.ENUM" class="anchor"></a><code>| </code><code><span class="constructor">ENUM</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-token.DEFINE_MINUS_CONST" class="anchored"><td class="def constructor"><a href="#type-token.DEFINE_MINUS_CONST" class="anchor"></a><code>| </code><code><span class="constructor">DEFINE_MINUS_CONST</span></code></td></tr><tr id="type-token.DECLARE_MINUS_CONST" class="anchored"><td class="def constructor"><a href="#type-token.DECLARE_MINUS_CONST" class="anchor"></a><code>| </code><code><span class="constructor">DECLARE_MINUS_CONST</span></code></td></tr><tr id="type-token.CONCAT" class="anchored"><td class="def constructor"><a href="#type-token.CONCAT" class="anchor"></a><code>| </code><code><span class="constructor">CONCAT</span></code></td></tr><tr id="type-token.COLON_VERSION" class="anchored"><td class="def constructor"><a href="#type-token.COLON_VERSION" class="anchor"></a><code>| </code><code><span class="constructor">COLON_VERSION</span></code></td></tr><tr id="type-token.CHECK_MINUS_SAT" class="anchored"><td class="def constructor"><a href="#type-token.CHECK_MINUS_SAT" class="anchor"></a><code>| </code><code><span class="constructor">CHECK_MINUS_SAT</span></code></td></tr><tr id="type-token.BVXOR" class="anchored"><td class="def constructor"><a href="#type-token.BVXOR" class="anchor"></a><code>| </code><code><span class="constructor">BVXOR</span></code></td></tr><tr id="type-token.BVXNOR" class="anchored"><td class="def constructor"><a href="#type-token.BVXNOR" class="anchor"></a><code>| </code><code><span class="constructor">BVXNOR</span></code></td></tr><tr id="type-token.BVUREM_UNDERSCORE_I" class="anchored"><td class="def constructor"><a href="#type-token.BVUREM_UNDERSCORE_I" class="anchor"></a><code>| </code><code><span class="constructor">BVUREM_UNDERSCORE_I</span></code></td></tr><tr id="type-token.BVUREM" class="anchored"><td class="def constructor"><a href="#type-token.BVUREM" class="anchor"></a><code>| </code><code><span class="constructor">BVUREM</span></code></td></tr><tr id="type-token.BVULT" class="anchored"><td class="def constructor"><a href="#type-token.BVULT" class="anchor"></a><code>| </code><code><span class="constructor">BVULT</span></code></td></tr><tr id="type-token.BVULE" class="anchored"><td class="def constructor"><a href="#type-token.BVULE" class="anchor"></a><code>| </code><code><span class="constructor">BVULE</span></code></td></tr><tr id="type-token.BVUGT" class="anchored"><td class="def constructor"><a href="#type-token.BVUGT" class="anchor"></a><code>| </code><code><span class="constructor">BVUGT</span></code></td></tr><tr id="type-token.BVUGE" class="anchored"><td class="def constructor"><a href="#type-token.BVUGE" class="anchor"></a><code>| </code><code><span class="constructor">BVUGE</span></code></td></tr><tr id="type-token.BVUDIV_UNDERSCORE_I" class="anchored"><td class="def constructor"><a href="#type-token.BVUDIV_UNDERSCORE_I" class="anchor"></a><code>| </code><code><span class="constructor">BVUDIV_UNDERSCORE_I</span></code></td></tr><tr id="type-token.BVUDIV" class="anchored"><td class="def constructor"><a href="#type-token.BVUDIV" class="anchor"></a><code>| </code><code><span class="constructor">BVUDIV</span></code></td></tr><tr id="type-token.BVSUB" class="anchored"><td class="def constructor"><a href="#type-token.BVSUB" class="anchor"></a><code>| </code><code><span class="constructor">BVSUB</span></code></td></tr><tr id="type-token.BVSREM_UNDERSCORE_I" class="anchored"><td class="def constructor"><a href="#type-token.BVSREM_UNDERSCORE_I" class="anchor"></a><code>| </code><code><span class="constructor">BVSREM_UNDERSCORE_I</span></code></td></tr><tr id="type-token.BVSREM" class="anchored"><td class="def constructor"><a href="#type-token.BVSREM" class="anchor"></a><code>| </code><code><span class="constructor">BVSREM</span></code></td></tr><tr id="type-token.BVSMOD_UNDERSCORE_I" class="anchored"><td class="def constructor"><a href="#type-token.BVSMOD_UNDERSCORE_I" class="anchor"></a><code>| </code><code><span class="constructor">BVSMOD_UNDERSCORE_I</span></code></td></tr><tr id="type-token.BVSMOD" class="anchored"><td class="def constructor"><a href="#type-token.BVSMOD" class="anchor"></a><code>| </code><code><span class="constructor">BVSMOD</span></code></td></tr><tr id="type-token.BVSLT" class="anchored"><td class="def constructor"><a href="#type-token.BVSLT" class="anchor"></a><code>| </code><code><span class="constructor">BVSLT</span></code></td></tr><tr id="type-token.BVSLE" class="anchored"><td class="def constructor"><a href="#type-token.BVSLE" class="anchor"></a><code>| </code><code><span class="constructor">BVSLE</span></code></td></tr><tr id="type-token.BVSHL" class="anchored"><td class="def constructor"><a href="#type-token.BVSHL" class="anchor"></a><code>| </code><code><span class="constructor">BVSHL</span></code></td></tr><tr id="type-token.BVSGT" class="anchored"><td class="def constructor"><a href="#type-token.BVSGT" class="anchor"></a><code>| </code><code><span class="constructor">BVSGT</span></code></td></tr><tr id="type-token.BVSGE" class="anchored"><td class="def constructor"><a href="#type-token.BVSGE" class="anchor"></a><code>| </code><code><span class="constructor">BVSGE</span></code></td></tr><tr id="type-token.BVSDIV_UNDERSCORE_I" class="anchored"><td class="def constructor"><a href="#type-token.BVSDIV_UNDERSCORE_I" class="anchor"></a><code>| </code><code><span class="constructor">BVSDIV_UNDERSCORE_I</span></code></td></tr><tr id="type-token.BVSDIV" class="anchored"><td class="def constructor"><a href="#type-token.BVSDIV" class="anchor"></a><code>| </code><code><span class="constructor">BVSDIV</span></code></td></tr><tr id="type-token.BVREDOR" class="anchored"><td class="def constructor"><a href="#type-token.BVREDOR" class="anchor"></a><code>| </code><code><span class="constructor">BVREDOR</span></code></td></tr><tr id="type-token.BVREDAND" class="anchored"><td class="def constructor"><a href="#type-token.BVREDAND" class="anchor"></a><code>| </code><code><span class="constructor">BVREDAND</span></code></td></tr><tr id="type-token.BVOR" class="anchored"><td class="def constructor"><a href="#type-token.BVOR" class="anchor"></a><code>| </code><code><span class="constructor">BVOR</span></code></td></tr><tr id="type-token.BVNOT" class="anchored"><td class="def constructor"><a href="#type-token.BVNOT" class="anchor"></a><code>| </code><code><span class="constructor">BVNOT</span></code></td></tr><tr id="type-token.BVNOR" class="anchored"><td class="def constructor"><a href="#type-token.BVNOR" class="anchor"></a><code>| </code><code><span class="constructor">BVNOR</span></code></td></tr><tr id="type-token.BVNEG" class="anchored"><td class="def constructor"><a href="#type-token.BVNEG" class="anchor"></a><code>| </code><code><span class="constructor">BVNEG</span></code></td></tr><tr id="type-token.BVNAND" class="anchored"><td class="def constructor"><a href="#type-token.BVNAND" class="anchor"></a><code>| </code><code><span class="constructor">BVNAND</span></code></td></tr><tr id="type-token.BVMUL" class="anchored"><td class="def constructor"><a href="#type-token.BVMUL" class="anchor"></a><code>| </code><code><span class="constructor">BVMUL</span></code></td></tr><tr id="type-token.BVLSHR" class="anchored"><td class="def constructor"><a href="#type-token.BVLSHR" class="anchor"></a><code>| </code><code><span class="constructor">BVLSHR</span></code></td></tr><tr id="type-token.BVI" class="anchored"><td class="def constructor"><a href="#type-token.BVI" class="anchor"></a><code>| </code><code><span class="constructor">BVI</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-token.BVF" class="anchored"><td class="def constructor"><a href="#type-token.BVF" class="anchor"></a><code>| </code><code><span class="constructor">BVF</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></code></td></tr><tr id="type-token.BVASHR" class="anchored"><td class="def constructor"><a href="#type-token.BVASHR" class="anchor"></a><code>| </code><code><span class="constructor">BVASHR</span></code></td></tr><tr id="type-token.BVAR" class="anchored"><td class="def constructor"><a href="#type-token.BVAR" class="anchor"></a><code>| </code><code><span class="constructor">BVAR</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-token.BVAND" class="anchored"><td class="def constructor"><a href="#type-token.BVAND" class="anchor"></a><code>| </code><code><span class="constructor">BVAND</span></code></td></tr><tr id="type-token.BVADD" class="anchored"><td class="def constructor"><a href="#type-token.BVADD" class="anchor"></a><code>| </code><code><span class="constructor">BVADD</span></code></td></tr><tr id="type-token.BV" class="anchored"><td class="def constructor"><a href="#type-token.BV" class="anchor"></a><code>| </code><code><span class="constructor">BV</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-token.BOOL" class="anchored"><td class="def constructor"><a href="#type-token.BOOL" class="anchor"></a><code>| </code><code><span class="constructor">BOOL</span></code></td></tr><tr id="type-token.BITVEC" class="anchored"><td class="def constructor"><a href="#type-token.BITVEC" class="anchor"></a><code>| </code><code><span class="constructor">BITVEC</span></code></td></tr><tr id="type-token.ASSERT" class="anchored"><td class="def constructor"><a href="#type-token.ASSERT" class="anchor"></a><code>| </code><code><span class="constructor">ASSERT</span></code></td></tr><tr id="type-token.ARRAY" class="anchored"><td class="def constructor"><a href="#type-token.ARRAY" class="anchor"></a><code>| </code><code><span class="constructor">ARRAY</span></code></td></tr><tr id="type-token.AND" class="anchored"><td class="def constructor"><a href="#type-token.AND" class="anchor"></a><code>| </code><code><span class="constructor">AND</span></code></td></tr></table></dt></dl><dl><dt class="spec exception" id="exception-Error"><a href="#exception-Error" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Error</span></code></dt></dl><dl><dt class="spec value" id="val-smts_start"><a href="#val-smts_start" class="anchor"></a><code><span class="keyword">val</span> smts_start : <span>(Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-token">token</a>)</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <span><a href="../Def/index.html#type-rsmt">Def.rsmt</a> list</span></code></dt><dt class="spec value" id="val-smt_start"><a href="#val-smt_start" class="anchor"></a><code><span class="keyword">val</span> smt_start : <span>(Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-token">token</a>)</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="../Def/index.html#type-rsmt">Def.rsmt</a></code></dt><dt class="spec value" id="val-smt_ans_start"><a href="#val-smt_ans_start" class="anchor"></a><code><span class="keyword">val</span> smt_ans_start : <span>(Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-token">token</a>)</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="../Def/index.html#type-rsmt_ans">Def.rsmt_ans</a></code></dt><dt class="spec value" id="val-exp_start"><a href="#val-exp_start" class="anchor"></a><code><span class="keyword">val</span> exp_start : <span>(Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-token">token</a>)</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <span><span>(<a href="../Def/index.html#type-lrng">Def.lrng</a>, string, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Parser (read-dwarf.AstGen.Parser)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Parser</nav><header class="odoc-preamble"><h1>Module <code><span>AstGen.Parser</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-token"><a href="#type-token" class="anchor"></a><code><span><span class="keyword">type</span> token</span><span> = </span></code><ol><li id="type-token.ZERO_UNDERSCORE_EXTEND" class="def variant constructor anchored"><a href="#type-token.ZERO_UNDERSCORE_EXTEND" class="anchor"></a><code><span>| </span><span><span class="constructor">ZERO_UNDERSCORE_EXTEND</span></span></code></li><li id="type-token.VVAR" class="def variant constructor anchored"><a href="#type-token.VVAR" class="anchor"></a><code><span>| </span><span><span class="constructor">VVAR</span> <span class="keyword">of</span> int</span></code></li><li id="type-token.UNSUPPORTED" class="def variant constructor anchored"><a href="#type-token.UNSUPPORTED" class="anchor"></a><code><span>| </span><span><span class="constructor">UNSUPPORTED</span></span></code></li><li id="type-token.UNSAT" class="def variant constructor anchored"><a href="#type-token.UNSAT" class="anchor"></a><code><span>| </span><span><span class="constructor">UNSAT</span></span></code></li><li id="type-token.UNKNOWN" class="def variant constructor anchored"><a href="#type-token.UNKNOWN" class="anchor"></a><code><span>| </span><span><span class="constructor">UNKNOWN</span></span></code></li><li id="type-token.TRUE" class="def variant constructor anchored"><a href="#type-token.TRUE" class="anchor"></a><code><span>| </span><span><span class="constructor">TRUE</span></span></code></li><li id="type-token.STR" class="def variant constructor anchored"><a href="#type-token.STR" class="anchor"></a><code><span>| </span><span><span class="constructor">STR</span> <span class="keyword">of</span> string</span></code></li><li id="type-token.STORE" class="def variant constructor anchored"><a href="#type-token.STORE" class="anchor"></a><code><span>| </span><span><span class="constructor">STORE</span></span></code></li><li id="type-token.SIMPLIFY" class="def variant constructor anchored"><a href="#type-token.SIMPLIFY" class="anchor"></a><code><span>| </span><span><span class="constructor">SIMPLIFY</span></span></code></li><li id="type-token.SIGN_UNDERSCORE_EXTEND" class="def variant constructor anchored"><a href="#type-token.SIGN_UNDERSCORE_EXTEND" class="anchor"></a><code><span>| </span><span><span class="constructor">SIGN_UNDERSCORE_EXTEND</span></span></code></li><li id="type-token.SELECT" class="def variant constructor anchored"><a href="#type-token.SELECT" class="anchor"></a><code><span>| </span><span><span class="constructor">SELECT</span></span></code></li><li id="type-token.SAT" class="def variant constructor anchored"><a href="#type-token.SAT" class="anchor"></a><code><span>| </span><span><span class="constructor">SAT</span></span></code></li><li id="type-token.RPAREN" class="def variant constructor anchored"><a href="#type-token.RPAREN" class="anchor"></a><code><span>| </span><span><span class="constructor">RPAREN</span></span></code></li><li id="type-token.PUSH" class="def variant constructor anchored"><a href="#type-token.PUSH" class="anchor"></a><code><span>| </span><span><span class="constructor">PUSH</span></span></code></li><li id="type-token.POP" class="def variant constructor anchored"><a href="#type-token.POP" class="anchor"></a><code><span>| </span><span><span class="constructor">POP</span></span></code></li><li id="type-token.OR" class="def variant constructor anchored"><a href="#type-token.OR" class="anchor"></a><code><span>| </span><span><span class="constructor">OR</span></span></code></li><li id="type-token.NOT" class="def variant constructor anchored"><a href="#type-token.NOT" class="anchor"></a><code><span>| </span><span><span class="constructor">NOT</span></span></code></li><li id="type-token.NAT" class="def variant constructor anchored"><a href="#type-token.NAT" class="anchor"></a><code><span>| </span><span><span class="constructor">NAT</span> <span class="keyword">of</span> int</span></code></li><li id="type-token.NAME" class="def variant constructor anchored"><a href="#type-token.NAME" class="anchor"></a><code><span>| </span><span><span class="constructor">NAME</span> <span class="keyword">of</span> string</span></code></li><li id="type-token.MINUS" class="def variant constructor anchored"><a href="#type-token.MINUS" class="anchor"></a><code><span>| </span><span><span class="constructor">MINUS</span></span></code></li><li id="type-token.MEM" class="def variant constructor anchored"><a href="#type-token.MEM" class="anchor"></a><code><span>| </span><span><span class="constructor">MEM</span></span></code></li><li id="type-token.LPAREN_UNDERSCORE" class="def variant constructor anchored"><a href="#type-token.LPAREN_UNDERSCORE" class="anchor"></a><code><span>| </span><span><span class="constructor">LPAREN_UNDERSCORE</span></span></code></li><li id="type-token.LPAREN" class="def variant constructor anchored"><a href="#type-token.LPAREN" class="anchor"></a><code><span>| </span><span><span class="constructor">LPAREN</span></span></code></li><li id="type-token.LET" class="def variant constructor anchored"><a href="#type-token.LET" class="anchor"></a><code><span>| </span><span><span class="constructor">LET</span></span></code></li><li id="type-token.ITE" class="def variant constructor anchored"><a href="#type-token.ITE" class="anchor"></a><code><span>| </span><span><span class="constructor">ITE</span></span></code></li><li id="type-token.GET_MINUS_INFO" class="def variant constructor anchored"><a href="#type-token.GET_MINUS_INFO" class="anchor"></a><code><span>| </span><span><span class="constructor">GET_MINUS_INFO</span></span></code></li><li id="type-token.FLAG" class="def variant constructor anchored"><a href="#type-token.FLAG" class="anchor"></a><code><span>| </span><span><span class="constructor">FLAG</span> <span class="keyword">of</span> string</span></code></li><li id="type-token.FALSE" class="def variant constructor anchored"><a href="#type-token.FALSE" class="anchor"></a><code><span>| </span><span><span class="constructor">FALSE</span></span></code></li><li id="type-token.EXTRACT" class="def variant constructor anchored"><a href="#type-token.EXTRACT" class="anchor"></a><code><span>| </span><span><span class="constructor">EXTRACT</span></span></code></li><li id="type-token.EXIT" class="def variant constructor anchored"><a href="#type-token.EXIT" class="anchor"></a><code><span>| </span><span><span class="constructor">EXIT</span></span></code></li><li id="type-token.ERROR" class="def variant constructor anchored"><a href="#type-token.ERROR" class="anchor"></a><code><span>| </span><span><span class="constructor">ERROR</span></span></code></li><li id="type-token.EQ" class="def variant constructor anchored"><a href="#type-token.EQ" class="anchor"></a><code><span>| </span><span><span class="constructor">EQ</span></span></code></li><li id="type-token.EOF" class="def variant constructor anchored"><a href="#type-token.EOF" class="anchor"></a><code><span>| </span><span><span class="constructor">EOF</span></span></code></li><li id="type-token.ENUM_UNDERSCORE_TY" class="def variant constructor anchored"><a href="#type-token.ENUM_UNDERSCORE_TY" class="anchor"></a><code><span>| </span><span><span class="constructor">ENUM_UNDERSCORE_TY</span> <span class="keyword">of</span> int</span></code></li><li id="type-token.ENUM" class="def variant constructor anchored"><a href="#type-token.ENUM" class="anchor"></a><code><span>| </span><span><span class="constructor">ENUM</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-token.DEFINE_MINUS_CONST" class="def variant constructor anchored"><a href="#type-token.DEFINE_MINUS_CONST" class="anchor"></a><code><span>| </span><span><span class="constructor">DEFINE_MINUS_CONST</span></span></code></li><li id="type-token.DECLARE_MINUS_CONST" class="def variant constructor anchored"><a href="#type-token.DECLARE_MINUS_CONST" class="anchor"></a><code><span>| </span><span><span class="constructor">DECLARE_MINUS_CONST</span></span></code></li><li id="type-token.CONCAT" class="def variant constructor anchored"><a href="#type-token.CONCAT" class="anchor"></a><code><span>| </span><span><span class="constructor">CONCAT</span></span></code></li><li id="type-token.COLON_VERSION" class="def variant constructor anchored"><a href="#type-token.COLON_VERSION" class="anchor"></a><code><span>| </span><span><span class="constructor">COLON_VERSION</span></span></code></li><li id="type-token.CHECK_MINUS_SAT" class="def variant constructor anchored"><a href="#type-token.CHECK_MINUS_SAT" class="anchor"></a><code><span>| </span><span><span class="constructor">CHECK_MINUS_SAT</span></span></code></li><li id="type-token.BVXOR" class="def variant constructor anchored"><a href="#type-token.BVXOR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVXOR</span></span></code></li><li id="type-token.BVXNOR" class="def variant constructor anchored"><a href="#type-token.BVXNOR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVXNOR</span></span></code></li><li id="type-token.BVUREM_UNDERSCORE_I" class="def variant constructor anchored"><a href="#type-token.BVUREM_UNDERSCORE_I" class="anchor"></a><code><span>| </span><span><span class="constructor">BVUREM_UNDERSCORE_I</span></span></code></li><li id="type-token.BVUREM" class="def variant constructor anchored"><a href="#type-token.BVUREM" class="anchor"></a><code><span>| </span><span><span class="constructor">BVUREM</span></span></code></li><li id="type-token.BVULT" class="def variant constructor anchored"><a href="#type-token.BVULT" class="anchor"></a><code><span>| </span><span><span class="constructor">BVULT</span></span></code></li><li id="type-token.BVULE" class="def variant constructor anchored"><a href="#type-token.BVULE" class="anchor"></a><code><span>| </span><span><span class="constructor">BVULE</span></span></code></li><li id="type-token.BVUGT" class="def variant constructor anchored"><a href="#type-token.BVUGT" class="anchor"></a><code><span>| </span><span><span class="constructor">BVUGT</span></span></code></li><li id="type-token.BVUGE" class="def variant constructor anchored"><a href="#type-token.BVUGE" class="anchor"></a><code><span>| </span><span><span class="constructor">BVUGE</span></span></code></li><li id="type-token.BVUDIV_UNDERSCORE_I" class="def variant constructor anchored"><a href="#type-token.BVUDIV_UNDERSCORE_I" class="anchor"></a><code><span>| </span><span><span class="constructor">BVUDIV_UNDERSCORE_I</span></span></code></li><li id="type-token.BVUDIV" class="def variant constructor anchored"><a href="#type-token.BVUDIV" class="anchor"></a><code><span>| </span><span><span class="constructor">BVUDIV</span></span></code></li><li id="type-token.BVSUB" class="def variant constructor anchored"><a href="#type-token.BVSUB" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSUB</span></span></code></li><li id="type-token.BVSREM_UNDERSCORE_I" class="def variant constructor anchored"><a href="#type-token.BVSREM_UNDERSCORE_I" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSREM_UNDERSCORE_I</span></span></code></li><li id="type-token.BVSREM" class="def variant constructor anchored"><a href="#type-token.BVSREM" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSREM</span></span></code></li><li id="type-token.BVSMOD_UNDERSCORE_I" class="def variant constructor anchored"><a href="#type-token.BVSMOD_UNDERSCORE_I" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSMOD_UNDERSCORE_I</span></span></code></li><li id="type-token.BVSMOD" class="def variant constructor anchored"><a href="#type-token.BVSMOD" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSMOD</span></span></code></li><li id="type-token.BVSLT" class="def variant constructor anchored"><a href="#type-token.BVSLT" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSLT</span></span></code></li><li id="type-token.BVSLE" class="def variant constructor anchored"><a href="#type-token.BVSLE" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSLE</span></span></code></li><li id="type-token.BVSHL" class="def variant constructor anchored"><a href="#type-token.BVSHL" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSHL</span></span></code></li><li id="type-token.BVSGT" class="def variant constructor anchored"><a href="#type-token.BVSGT" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSGT</span></span></code></li><li id="type-token.BVSGE" class="def variant constructor anchored"><a href="#type-token.BVSGE" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSGE</span></span></code></li><li id="type-token.BVSDIV_UNDERSCORE_I" class="def variant constructor anchored"><a href="#type-token.BVSDIV_UNDERSCORE_I" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSDIV_UNDERSCORE_I</span></span></code></li><li id="type-token.BVSDIV" class="def variant constructor anchored"><a href="#type-token.BVSDIV" class="anchor"></a><code><span>| </span><span><span class="constructor">BVSDIV</span></span></code></li><li id="type-token.BVREDOR" class="def variant constructor anchored"><a href="#type-token.BVREDOR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVREDOR</span></span></code></li><li id="type-token.BVREDAND" class="def variant constructor anchored"><a href="#type-token.BVREDAND" class="anchor"></a><code><span>| </span><span><span class="constructor">BVREDAND</span></span></code></li><li id="type-token.BVOR" class="def variant constructor anchored"><a href="#type-token.BVOR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVOR</span></span></code></li><li id="type-token.BVNOT" class="def variant constructor anchored"><a href="#type-token.BVNOT" class="anchor"></a><code><span>| </span><span><span class="constructor">BVNOT</span></span></code></li><li id="type-token.BVNOR" class="def variant constructor anchored"><a href="#type-token.BVNOR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVNOR</span></span></code></li><li id="type-token.BVNEG" class="def variant constructor anchored"><a href="#type-token.BVNEG" class="anchor"></a><code><span>| </span><span><span class="constructor">BVNEG</span></span></code></li><li id="type-token.BVNAND" class="def variant constructor anchored"><a href="#type-token.BVNAND" class="anchor"></a><code><span>| </span><span><span class="constructor">BVNAND</span></span></code></li><li id="type-token.BVMUL" class="def variant constructor anchored"><a href="#type-token.BVMUL" class="anchor"></a><code><span>| </span><span><span class="constructor">BVMUL</span></span></code></li><li id="type-token.BVLSHR" class="def variant constructor anchored"><a href="#type-token.BVLSHR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVLSHR</span></span></code></li><li id="type-token.BVI" class="def variant constructor anchored"><a href="#type-token.BVI" class="anchor"></a><code><span>| </span><span><span class="constructor">BVI</span> <span class="keyword">of</span> int</span></code></li><li id="type-token.BVF" class="def variant constructor anchored"><a href="#type-token.BVF" class="anchor"></a><code><span>| </span><span><span class="constructor">BVF</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></span></code></li><li id="type-token.BVASHR" class="def variant constructor anchored"><a href="#type-token.BVASHR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVASHR</span></span></code></li><li id="type-token.BVAR" class="def variant constructor anchored"><a href="#type-token.BVAR" class="anchor"></a><code><span>| </span><span><span class="constructor">BVAR</span> <span class="keyword">of</span> string</span></code></li><li id="type-token.BVAND" class="def variant constructor anchored"><a href="#type-token.BVAND" class="anchor"></a><code><span>| </span><span><span class="constructor">BVAND</span></span></code></li><li id="type-token.BVADD" class="def variant constructor anchored"><a href="#type-token.BVADD" class="anchor"></a><code><span>| </span><span><span class="constructor">BVADD</span></span></code></li><li id="type-token.BV" class="def variant constructor anchored"><a href="#type-token.BV" class="anchor"></a><code><span>| </span><span><span class="constructor">BV</span> <span class="keyword">of</span> string</span></code></li><li id="type-token.BOOL" class="def variant constructor anchored"><a href="#type-token.BOOL" class="anchor"></a><code><span>| </span><span><span class="constructor">BOOL</span></span></code></li><li id="type-token.BITVEC" class="def variant constructor anchored"><a href="#type-token.BITVEC" class="anchor"></a><code><span>| </span><span><span class="constructor">BITVEC</span></span></code></li><li id="type-token.ASSERT" class="def variant constructor anchored"><a href="#type-token.ASSERT" class="anchor"></a><code><span>| </span><span><span class="constructor">ASSERT</span></span></code></li><li id="type-token.ARRAY" class="def variant constructor anchored"><a href="#type-token.ARRAY" class="anchor"></a><code><span>| </span><span><span class="constructor">ARRAY</span></span></code></li><li id="type-token.AND" class="def variant constructor anchored"><a href="#type-token.AND" class="anchor"></a><code><span>| </span><span><span class="constructor">AND</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Error"><a href="#exception-Error" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Error</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smts_start"><a href="#val-smts_start" class="anchor"></a><code><span><span class="keyword">val</span> smts_start : 
+  <span><span>(<span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-token">token</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Def/index.html#type-rsmt">Def.rsmt</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smt_start"><a href="#val-smt_start" class="anchor"></a><code><span><span class="keyword">val</span> smt_start : 
+  <span><span>(<span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-token">token</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <a href="../Def/index.html#type-rsmt">Def.rsmt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smt_ans_start"><a href="#val-smt_ans_start" class="anchor"></a><code><span><span class="keyword">val</span> smt_ans_start : 
+  <span><span>(<span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-token">token</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <a href="../Def/index.html#type-rsmt_ans">Def.rsmt_ans</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_start"><a href="#val-exp_start" class="anchor"></a><code><span><span class="keyword">val</span> exp_start : 
+  <span><span>(<span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-token">token</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../Def/index.html#type-lrng">Def.lrng</a>, string, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/Parser_pp/index.html b/doc/html/read-dwarf/AstGen/Parser_pp/index.html
index c7fdf775..7c5e947e 100644
--- a/doc/html/read-dwarf/AstGen/Parser_pp/index.html
+++ b/doc/html/read-dwarf/AstGen/Parser_pp/index.html
@@ -1,2 +1,32 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Parser_pp (read-dwarf.AstGen.Parser_pp)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Parser_pp</nav><h1>Module <code>AstGen.Parser_pp</code></h1></header><dl><dt class="spec value" id="val-pp_raw_bvar"><a href="#val-pp_raw_bvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvf"><a href="#val-pp_raw_bvf" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvf : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_flag"><a href="#val-pp_raw_flag" class="anchor"></a><code><span class="keyword">val</span> pp_raw_flag : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span class="keyword">val</span> pp_raw_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum : <a href="../Ott/index.html#type-enum">Ott.enum</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span class="keyword">val</span> pp_raw_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span class="keyword">val</span> pp_raw_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_mem_size"><a href="#val-pp_raw_mem_size" class="anchor"></a><code><span class="keyword">val</span> pp_raw_mem_size : <a href="../Def/Size/index.html#type-t">Def.Size.t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_raw_binmem"><a href="#val-pp_raw_binmem" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binmem : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binmem">Ott.binmem</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_var"><a href="#val-pp_raw_var" class="anchor"></a><code><span class="keyword">val</span> pp_raw_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bbvar"><a href="#val-pp_raw_bbvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bbvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bind"><a href="#val-pp_raw_bind" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bind : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span>)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_fbool"><a href="#val-pp_raw_fbool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_fbool : <span>(string * bool)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smts"><a href="#val-pp_raw_smts" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smts : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt_ans"><a href="#val-pp_raw_smt_ans" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt_ans : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt_ans">Ott.smt_ans</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_ty : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-ty">Ott.ty</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_unop : <a href="../Ott/index.html#type-unop">Ott.unop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvarith : <a href="../Ott/index.html#type-bvarith">Ott.bvarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvcomp : <a href="../Ott/index.html#type-bvcomp">Ott.bvcomp</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binop : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binop">Ott.binop</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvmanyarith : <a href="../Ott/index.html#type-bvmanyarith">Ott.bvmanyarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_manyop : <a href="../Ott/index.html#type-manyop">Ott.manyop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvar"><a href="#val-pp_bvar" class="anchor"></a><code><span class="keyword">val</span> pp_bvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvf"><a href="#val-pp_bvf" class="anchor"></a><code><span class="keyword">val</span> pp_bvf : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_flag"><a href="#val-pp_flag" class="anchor"></a><code><span class="keyword">val</span> pp_flag : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span class="keyword">val</span> pp_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span class="keyword">val</span> pp_enum : <a href="../Ott/index.html#type-enum">Ott.enum</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span class="keyword">val</span> pp_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span class="keyword">val</span> pp_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span class="keyword">val</span> pp_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span class="keyword">val</span> pp_j : int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_mem_size"><a href="#val-pp_mem_size" class="anchor"></a><code><span class="keyword">val</span> pp_mem_size : <a href="../Def/Size/index.html#type-t">Def.Size.t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_binmem"><a href="#val-pp_binmem" class="anchor"></a><code><span class="keyword">val</span> pp_binmem : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binmem">Ott.binmem</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_var"><a href="#val-pp_var" class="anchor"></a><code><span class="keyword">val</span> pp_var : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bbvar"><a href="#val-pp_bbvar" class="anchor"></a><code><span class="keyword">val</span> pp_bbvar : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bind"><a href="#val-pp_bind" class="anchor"></a><code><span class="keyword">val</span> pp_bind : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span>)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_fbool"><a href="#val-pp_fbool" class="anchor"></a><code><span class="keyword">val</span> pp_fbool : <span>(string * bool)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smts"><a href="#val-pp_smts" class="anchor"></a><code><span class="keyword">val</span> pp_smts : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt_ans"><a href="#val-pp_smt_ans" class="anchor"></a><code><span class="keyword">val</span> pp_smt_ans : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt_ans">Ott.smt_ans</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span class="keyword">val</span> pp_ty : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-ty">Ott.ty</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span class="keyword">val</span> pp_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span class="keyword">val</span> pp_unop : <a href="../Ott/index.html#type-unop">Ott.unop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvarith : <a href="../Ott/index.html#type-bvarith">Ott.bvarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_bvcomp : <a href="../Ott/index.html#type-bvcomp">Ott.bvcomp</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span class="keyword">val</span> pp_binop : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binop">Ott.binop</a></span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvmanyarith : <a href="../Ott/index.html#type-bvmanyarith">Ott.bvmanyarith</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_manyop : <a href="../Ott/index.html#type-manyop">Ott.manyop</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Parser_pp (read-dwarf.AstGen.Parser_pp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">AstGen</a> &#x00BB; Parser_pp</nav><header class="odoc-preamble"><h1>Module <code><span>AstGen.Parser_pp</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvar"><a href="#val-pp_raw_bvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvf"><a href="#val-pp_raw_bvf" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvf : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_flag"><a href="#val-pp_raw_flag" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_flag : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum : <span><a href="../Ott/index.html#type-enum">Ott.enum</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_nat"><a href="#val-pp_raw_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_mem_size"><a href="#val-pp_raw_mem_size" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_mem_size : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binmem"><a href="#val-pp_raw_binmem" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binmem : <span><span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binmem">Ott.binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_var"><a href="#val-pp_raw_var" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_var : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bbvar"><a href="#val-pp_raw_bbvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bbvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bind"><a href="#val-pp_raw_bind" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bind : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_fbool"><a href="#val-pp_raw_fbool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_fbool : <span><span>(string * bool)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smts"><a href="#val-pp_raw_smts" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smts : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt_ans"><a href="#val-pp_raw_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt_ans : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt_ans">Ott.smt_ans</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_ty : <span><span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-ty">Ott.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_unop : <span><a href="../Ott/index.html#type-unop">Ott.unop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvarith : <span><a href="../Ott/index.html#type-bvarith">Ott.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvcomp : <span><a href="../Ott/index.html#type-bvcomp">Ott.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binop : <span><span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binop">Ott.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvmanyarith : <span><a href="../Ott/index.html#type-bvmanyarith">Ott.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_manyop : <span><a href="../Ott/index.html#type-manyop">Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvar"><a href="#val-pp_bvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvf"><a href="#val-pp_bvf" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvf : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_flag"><a href="#val-pp_flag" class="anchor"></a><code><span><span class="keyword">val</span> pp_flag : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum : <span><a href="../Ott/index.html#type-enum">Ott.enum</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_nat"><a href="#val-pp_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span><span class="keyword">val</span> pp_j : <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_mem_size"><a href="#val-pp_mem_size" class="anchor"></a><code><span><span class="keyword">val</span> pp_mem_size : <span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binmem"><a href="#val-pp_binmem" class="anchor"></a><code><span><span class="keyword">val</span> pp_binmem : <span><span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binmem">Ott.binmem</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_var"><a href="#val-pp_var" class="anchor"></a><code><span><span class="keyword">val</span> pp_var : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bbvar"><a href="#val-pp_bbvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bbvar : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bind"><a href="#val-pp_bind" class="anchor"></a><code><span><span class="keyword">val</span> pp_bind : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-exp">Ott.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_fbool"><a href="#val-pp_fbool" class="anchor"></a><code><span><span class="keyword">val</span> pp_fbool : <span><span>(string * bool)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smts"><a href="#val-pp_smts" class="anchor"></a><code><span><span class="keyword">val</span> pp_smts : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt">Ott.smt</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt_ans"><a href="#val-pp_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt_ans : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../Def/Size/index.html#type-t">Def.Size.t</a>)</span> <a href="../Ott/index.html#type-smt_ans">Ott.smt_ans</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_ty : <span><span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-ty">Ott.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_unop : <span><a href="../Ott/index.html#type-unop">Ott.unop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvarith : <span><a href="../Ott/index.html#type-bvarith">Ott.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvcomp : <span><a href="../Ott/index.html#type-bvcomp">Ott.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_binop : <span><span><a href="../Def/Size/index.html#type-t">Def.Size.t</a> <a href="../Ott/index.html#type-binop">Ott.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvmanyarith : <span><a href="../Ott/index.html#type-bvmanyarith">Ott.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_manyop : <span><a href="../Ott/index.html#type-manyop">Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/AstGen/index.html b/doc/html/read-dwarf/AstGen/index.html
index f331ac6a..13c57145 100644
--- a/doc/html/read-dwarf/AstGen/index.html
+++ b/doc/html/read-dwarf/AstGen/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>AstGen (read-dwarf.AstGen)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; AstGen</nav><h1>Module <code>AstGen</code></h1></header><dl><dt class="spec module" id="module-Def"><a href="#module-Def" class="anchor"></a><code><span class="keyword">module</span> <a href="Def/index.html">Def</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span class="keyword">module</span> <a href="Lexer/index.html">Lexer</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Ott"><a href="#module-Ott" class="anchor"></a><code><span class="keyword">module</span> <a href="Ott/index.html">Ott</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span class="keyword">module</span> <a href="Parser/index.html">Parser</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Parser_pp"><a href="#module-Parser_pp" class="anchor"></a><code><span class="keyword">module</span> <a href="Parser_pp/index.html">Parser_pp</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>AstGen (read-dwarf.AstGen)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; AstGen</nav><header class="odoc-preamble"><h1>Module <code><span>AstGen</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Def"><a href="#module-Def" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Def/index.html">Def</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Lexer/index.html">Lexer</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Ott"><a href="#module-Ott" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Ott/index.html">Ott</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>warning: the backend selected ignores the file structure informations</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Parser/index.html">Parser</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Parser_pp"><a href="#module-Parser_pp" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Parser_pp/index.html">Parser_pp</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/BinaryAnalysis.html b/doc/html/read-dwarf/BinaryAnalysis.html
index 6ebccd99..df558e32 100644
--- a/doc/html/read-dwarf/BinaryAnalysis.html
+++ b/doc/html/read-dwarf/BinaryAnalysis.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BinaryAnalysis (read-dwarf.BinaryAnalysis)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; BinaryAnalysis</nav><h1 id="binary-analysis"><a href="#binary-analysis" class="anchor"></a>Binary Analysis</h1><p>This page is about how we analyse the ELF and DWARF information in binary files All the module in this page provide a wrapping interface around <code>linksem</code>. An important convention is that if there is an internal type with a name, the corresponding type in linksem representing the same concept is named <code>linksem_name</code>.</p><nav class="toc"><ul><li><a href="#analyse">Analyse</a></li><li><a href="#elf">ELF</a></li><li><a href="#dwarf">DWARF</a></li></ul></nav></header><h2 id="analyse"><a href="#analyse" class="anchor"></a>Analyse</h2><p>TODO: There is a lot a binary analysis code in <code>Analyse*</code> modules that should be documented.</p><h2 id="elf"><a href="#elf" class="anchor"></a>ELF</h2><p>The <a href="Elf/index.html"><code>Elf</code></a> group of modules provide the main interface to ELF information. It will parse the <a href="Elf/File/index.html"><span>ELF file</span></a> and extract the <a href="Elf/SymTable/index.html"><span>symbol table</span></a>. In particular they provide direct access to ELF <a href="Elf/Symbol/index.html"><span>symbols</span></a> like function and global variables.</p><h2 id="dwarf"><a href="#dwarf" class="anchor"></a>DWARF</h2><p>DWARF information is processed after <code>linksem</code> by the <a href="Dw/index.html"><code>Dw</code></a> modules, for <a href="Dw/Func/index.html"><span>functions</span></a> and <a href="Dw/Var/index.html"><span>variables</span></a>. This step also does C type linking in <a href="Ctype/index.html"><code>Ctype</code></a> and inverting DWARF location in <a href="Dw/Loc/index.html"><code>Dw.Loc</code></a>.</p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BinaryAnalysis (read-dwarf.BinaryAnalysis)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; BinaryAnalysis</nav><header class="odoc-preamble"><h1 id="binary-analysis"><a href="#binary-analysis" class="anchor"></a>Binary Analysis</h1><p>This page is about how we analyse the ELF and DWARF information in binary files All the module in this page provide a wrapping interface around <code>linksem</code>. An important convention is that if there is an internal type with a name, the corresponding type in linksem representing the same concept is named <code>linksem_name</code>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#analyse">Analyse</a></li><li><a href="#elf">ELF</a></li><li><a href="#dwarf">DWARF</a></li></ul></nav></div><div class="odoc-content"><h2 id="analyse"><a href="#analyse" class="anchor"></a>Analyse</h2><p>TODO: There is a lot a binary analysis code in <code>Analyse*</code> modules that should be documented.</p><h2 id="elf"><a href="#elf" class="anchor"></a>ELF</h2><p>The <a href="Elf/index.html"><code>Elf</code></a> group of modules provide the main interface to ELF information. It will parse the <a href="Elf/File/index.html" title="Elf.File">ELF file</a> and extract the <a href="Elf/SymTable/index.html" title="Elf.SymTable">symbol table</a>. In particular they provide direct access to ELF <a href="Elf/Symbol/index.html" title="Elf.Symbol">symbols</a> like function and global variables.</p><h2 id="dwarf"><a href="#dwarf" class="anchor"></a>DWARF</h2><p>DWARF information is processed after <code>linksem</code> by the <a href="Dw/index.html"><code>Dw</code></a> modules, for <a href="Dw/Func/index.html" title="Dw.Func">functions</a> and <a href="Dw/Var/index.html" title="Dw.Var">variables</a>. This step also does C type linking in <a href="Ctype/index.html"><code>Ctype</code></a> and inverting DWARF location in <a href="Dw/Loc/index.html"><code>Dw.Loc</code></a>.</p></div></body></html>
diff --git a/doc/html/read-dwarf/CLI.html b/doc/html/read-dwarf/CLI.html
index 01570f7b..76c7fb20 100644
--- a/doc/html/read-dwarf/CLI.html
+++ b/doc/html/read-dwarf/CLI.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CLI (read-dwarf.CLI)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; CLI</nav><h1 id="command-line-interface"><a href="#command-line-interface" class="anchor"></a>Command line interface</h1><p><code>read-dwarf</code> as a various set of subcommand for testing various aspect of the code. They are call like <code>read-dwarf subcommand --options ..</code>. The convention is that for each subcommand there is a corresponding module. For example the <code>run-func</code> subcommand is implemented in <a href="Run/Func/index.html"><code>Run.Func</code></a>. All the command line interface of read-dwarf use the <code>cmdliner</code> library. Those module export a <code>command</code> value like <a href="Run/Func/index.html#val-command"><code>Run.Func.command</code></a>. This value is then used by <code>Main</code> to build and call the main command line.</p><p>To add a new subcommand, you have to make a new module, with the logic of that subcommand, export a <code>command</code> value, and add that value in <code>Main</code>.</p><nav class="toc"><ul><li><a href="#common-options">Common options</a></li><li><a href="#low-level-isla-testing">Low-level isla testing</a></li><li><a href="#information-dumping">Information dumping</a></li><li><a href="#symbolic-execution">Symbolic Execution</a></li><li><a href="#cache-maintenance">Cache maintenance</a></li></ul></nav></header><h2 id="common-options"><a href="#common-options" class="anchor"></a>Common options</h2><p>There are a certain number of common options for setting binary paths or config file locations from the command line. They are all defined in <a href="Config/CommonOpt/index.html"><code>Config.CommonOpt</code></a>. This module also contain common <code>cmdliner</code> infrastructure.</p><h2 id="low-level-isla-testing"><a href="#low-level-isla-testing" class="anchor"></a>Low-level isla testing</h2><p>This section is about command to test the isla interaction on single instructions. All those subcommand start with <code>isla-*</code>.</p><ul><li><code>isla-server</code> (in <a href="Isla__/Server/Cmd/index.html"><code>Isla.Server.Cmd</code></a>) allow to do manual call to the isla server. The input is un-parsed and transmitted as raw text to isla, however the result is parsed and printed again as the protocol is partially a binary protocol.</li></ul><ul><li><code>isla-test</code> (in <a href="Isla/Test/index.html"><code>Isla.Test</code></a>) allow to test all the elements of the pipeline individually. In particular it allows to parse an isla trace text from disk and other similar low-level testing operation. It completely ignores the <a href="Isla/Cache/index.html"><code>Isla.Cache</code></a>.</li></ul><h2 id="information-dumping"><a href="#information-dumping" class="anchor"></a>Information dumping</h2><p>This section is about sub-commands that dump ELF and DWARF information without doing any symbolic execution.</p><ul><li><code>rd</code> (in <a href="Run/ReadDwarf/index.html"><code>Run.ReadDwarf</code></a>) : Dumps an ELF file in the read-dwarf format. DWARF information is interleaved with the result of the objdump, so one can see how the dwarf information is positioned compared to the assembly. It will also try to read the source file to interleave the original source code.</li><li><code>dump-sym</code> (in <a href="Other_cmds/DumpSym/index.html"><code>Other_cmds.DumpSym</code></a>) : Dumps the ELF symbols as parsed by the <a href="Elf/index.html"><code>Elf</code></a> modules.</li><li><code>dump-dwarf</code> (in <a href="Other_cmds/DumpDwarf/index.html"><code>Other_cmds.DumpDwarf</code></a>) : Dumps the ELF information as parsed by the <a href="Dw/index.html"><code>Dw</code></a> modules.</li></ul><h2 id="symbolic-execution"><a href="#symbolic-execution" class="anchor"></a>Symbolic Execution</h2><p>This section is about sub-commands that test the symbolic execution engine. They all start with <code>run-*</code>.</p><ul><li><code>run-instr</code> (in <a href="Run/Instr/index.html"><code>Run.Instr</code></a>): Run a single instruction. Can also dump its <a href="Trace/index.html"><code>Trace</code></a>.</li><li><code>run-bb</code> (in <a href="Run/BB/index.html"><code>Run.BB</code></a>): Run a basic block. This will run instructions in order, without updating the PC: Any jump will be ignored.</li><li><code>run-block</code> (in <a href="Run/Block/index.html"><code>Run.Block</code></a>): Run a complex block of instruction. One need to specify a start point and an end condition.</li><li><code>run-func</code> (in <a href="Run/Func/index.html"><code>Run.Func</code></a>): Same as <code>run-block</code> but start at function start and does proper function entry initialization according to the ABI.</li><li><code>run-func-rd</code> (in <a href="Run/FuncRD/index.html"><code>Run.FuncRD</code></a>: Same as <code>run-func</code> but also interleave the <code>rd</code> output.</li></ul><h2 id="cache-maintenance"><a href="#cache-maintenance" class="anchor"></a>Cache maintenance</h2><p>The <code>read-dwarf cache</code> sub-command (in <span class="xref-unresolved" title="unresolved reference to &quot;Utils.Cache.cmd&quot;"><a href="Utils/index.html#module-Cache"><code>Utils.Cache</code></a>.cmd</span>) provides some cache maintenance operations.</p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CLI (read-dwarf.CLI)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; CLI</nav><header class="odoc-preamble"><h1 id="command-line-interface"><a href="#command-line-interface" class="anchor"></a>Command line interface</h1><p><code>read-dwarf</code> as a various set of subcommand for testing various aspect of the code. They are call like <code>read-dwarf subcommand --options ..</code>. The convention is that for each subcommand there is a corresponding module. For example the <code>run-func</code> subcommand is implemented in <a href="Run/Func/index.html"><code>Run.Func</code></a>. All the command line interface of read-dwarf use the <code>cmdliner</code> library. Those module export a <code>command</code> value like <a href="Run/Func/index.html#val-command"><code>Run.Func.command</code></a>. This value is then used by <code>Main</code> to build and call the main command line.</p><p>To add a new subcommand, you have to make a new module, with the logic of that subcommand, export a <code>command</code> value, and add that value in <code>Main</code>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#common-options">Common options</a></li><li><a href="#low-level-isla-testing">Low-level isla testing</a></li><li><a href="#information-dumping">Information dumping</a></li><li><a href="#symbolic-execution">Symbolic Execution</a></li><li><a href="#cache-maintenance">Cache maintenance</a></li></ul></nav></div><div class="odoc-content"><h2 id="common-options"><a href="#common-options" class="anchor"></a>Common options</h2><p>There are a certain number of common options for setting binary paths or config file locations from the command line. They are all defined in <a href="Config/CommonOpt/index.html"><code>Config.CommonOpt</code></a>. This module also contain common <code>cmdliner</code> infrastructure.</p><h2 id="low-level-isla-testing"><a href="#low-level-isla-testing" class="anchor"></a>Low-level isla testing</h2><p>This section is about command to test the isla interaction on single instructions. All those subcommand start with <code>isla-*</code>.</p><ul><li><code>isla-server</code> (in <a href="Isla/Server/Cmd/index.html"><code>Isla.Server.Cmd</code></a>) allow to do manual call to the isla server. The input is un-parsed and transmitted as raw text to isla, however the result is parsed and printed again as the protocol is partially a binary protocol.</li></ul><ul><li><code>isla-test</code> (in <a href="Isla/Test/index.html"><code>Isla.Test</code></a>) allow to test all the elements of the pipeline individually. In particular it allows to parse an isla trace text from disk and other similar low-level testing operation. It completely ignores the <a href="Isla/Cache/index.html"><code>Isla.Cache</code></a>.</li></ul><h2 id="information-dumping"><a href="#information-dumping" class="anchor"></a>Information dumping</h2><p>This section is about sub-commands that dump ELF and DWARF information without doing any symbolic execution.</p><ul><li><code>rd</code> (in <a href="Run/ReadDwarf/index.html"><code>Run.ReadDwarf</code></a>) : Dumps an ELF file in the read-dwarf format. DWARF information is interleaved with the result of the objdump, so one can see how the dwarf information is positioned compared to the assembly. It will also try to read the source file to interleave the original source code.</li><li><code>dump-sym</code> (in <a href="Other_cmds/DumpSym/index.html"><code>Other_cmds.DumpSym</code></a>) : Dumps the ELF symbols as parsed by the <a href="Elf/index.html"><code>Elf</code></a> modules.</li><li><code>dump-dwarf</code> (in <a href="Other_cmds/DumpDwarf/index.html"><code>Other_cmds.DumpDwarf</code></a>) : Dumps the ELF information as parsed by the <a href="Dw/index.html"><code>Dw</code></a> modules.</li></ul><h2 id="symbolic-execution"><a href="#symbolic-execution" class="anchor"></a>Symbolic Execution</h2><p>This section is about sub-commands that test the symbolic execution engine. They all start with <code>run-*</code>.</p><ul><li><code>run-instr</code> (in <a href="Run/Instr/index.html"><code>Run.Instr</code></a>): Run a single instruction. Can also dump its <a href="Trace/index.html"><code>Trace</code></a>.</li><li><code>run-bb</code> (in <a href="Run/BB/index.html"><code>Run.BB</code></a>): Run a basic block. This will run instructions in order, without updating the PC: Any jump will be ignored.</li><li><code>run-block</code> (in <a href="Run/Block/index.html"><code>Run.Block</code></a>): Run a complex block of instruction. One need to specify a start point and an end condition.</li><li><code>run-func</code> (in <a href="Run/Func/index.html"><code>Run.Func</code></a>): Same as <code>run-block</code> but start at function start and does proper function entry initialization according to the ABI.</li><li><code>run-func-rd</code> (in <a href="Run/FuncRD/index.html"><code>Run.FuncRD</code></a>: Same as <code>run-func</code> but also interleave the <code>rd</code> output.</li></ul><h2 id="cache-maintenance"><a href="#cache-maintenance" class="anchor"></a>Cache maintenance</h2><p>The <code>read-dwarf cache</code> sub-command (in <code>Utils.Cache.cmd</code>) provides some cache maintenance operations.</p></div></body></html>
diff --git a/doc/html/read-dwarf/Config/Arch/index.html b/doc/html/read-dwarf/Config/Arch/index.html
index 2e35b5e1..4c42bca2 100644
--- a/doc/html/read-dwarf/Config/Arch/index.html
+++ b/doc/html/read-dwarf/Config/Arch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Arch (read-dwarf.Config.Arch)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; Arch</nav><h1>Module <code>Config.Arch</code></h1><p>This module provides an enumeration of architecture for internal identification</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.X86" class="anchored"><td class="def constructor"><a href="#type-t.X86" class="anchor"></a><code>| </code><code><span class="constructor">X86</span></code></td></tr><tr id="type-t.X86_64" class="anchored"><td class="def constructor"><a href="#type-t.X86_64" class="anchor"></a><code>| </code><code><span class="constructor">X86_64</span></code></td></tr><tr id="type-t.PpC" class="anchored"><td class="def constructor"><a href="#type-t.PpC" class="anchor"></a><code>| </code><code><span class="constructor">PpC</span></code></td></tr><tr id="type-t.PpC64" class="anchored"><td class="def constructor"><a href="#type-t.PpC64" class="anchor"></a><code>| </code><code><span class="constructor">PpC64</span></code></td></tr><tr id="type-t.ARM" class="anchored"><td class="def constructor"><a href="#type-t.ARM" class="anchor"></a><code>| </code><code><span class="constructor">ARM</span></code></td></tr><tr id="type-t.AARCH64" class="anchored"><td class="def constructor"><a href="#type-t.AARCH64" class="anchor"></a><code>| </code><code><span class="constructor">AARCH64</span></code></td></tr></table></dt><dd><p>The supported architectures</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-size"><a href="#val-size" class="anchor"></a><code><span class="keyword">val</span> size : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-fmt"><a href="#val-fmt" class="anchor"></a><code><span class="keyword">val</span> fmt : Stdlib.Format.formatter <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-conv"><a href="#val-conv" class="anchor"></a><code><span class="keyword">val</span> conv : <span><a href="index.html#type-t">t</a> Cmdliner.Arg.conv</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Arch (read-dwarf.Config.Arch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; Arch</nav><header class="odoc-preamble"><h1>Module <code><span>Config.Arch</span></code></h1><p>This module provides an enumeration of architecture for internal identification</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.X86" class="def variant constructor anchored"><a href="#type-t.X86" class="anchor"></a><code><span>| </span><span><span class="constructor">X86</span></span></code></li><li id="type-t.X86_64" class="def variant constructor anchored"><a href="#type-t.X86_64" class="anchor"></a><code><span>| </span><span><span class="constructor">X86_64</span></span></code></li><li id="type-t.PpC" class="def variant constructor anchored"><a href="#type-t.PpC" class="anchor"></a><code><span>| </span><span><span class="constructor">PpC</span></span></code></li><li id="type-t.PpC64" class="def variant constructor anchored"><a href="#type-t.PpC64" class="anchor"></a><code><span>| </span><span><span class="constructor">PpC64</span></span></code></li><li id="type-t.ARM" class="def variant constructor anchored"><a href="#type-t.ARM" class="anchor"></a><code><span>| </span><span><span class="constructor">ARM</span></span></code></li><li id="type-t.AARCH64" class="def variant constructor anchored"><a href="#type-t.AARCH64" class="anchor"></a><code><span>| </span><span><span class="constructor">AARCH64</span></span></code></li><li id="type-t.RISCV64" class="def variant constructor anchored"><a href="#type-t.RISCV64" class="anchor"></a><code><span>| </span><span><span class="constructor">RISCV64</span></span></code></li></ol></div><div class="spec-doc"><p>The supported architectures</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-size"><a href="#val-size" class="anchor"></a><code><span><span class="keyword">val</span> size : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fmt"><a href="#val-fmt" class="anchor"></a><code><span><span class="keyword">val</span> fmt : <span><span class="xref-unresolved">Stdlib</span>.Format.formatter <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv"><a href="#val-conv" class="anchor"></a><code><span><span class="keyword">val</span> conv : <span><a href="#type-t">t</a> <span class="xref-unresolved">Cmdliner</span>.Arg.conv</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/CommonOpt/index.html b/doc/html/read-dwarf/Config/CommonOpt/index.html
index 481df931..a17b71ad 100644
--- a/doc/html/read-dwarf/Config/CommonOpt/index.html
+++ b/doc/html/read-dwarf/Config/CommonOpt/index.html
@@ -1,2 +1,7 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CommonOpt (read-dwarf.Config.CommonOpt)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; CommonOpt</nav><h1>Module <code>Config.CommonOpt</code></h1><p>This module provide support for common command line option to be used across multiple subcomands.</p><p>It also provide some <a href="../../Utils/index.html"><span>utilities</span></a> on the command line.</p><nav class="toc"><ul><li><a href="#exit-codes">Exit codes</a></li><li><a href="#config-options">Config options</a></li><li><a href="#isla-options">Isla options</a></li><li><a href="#z3-options">Z3 options</a></li><li><a href="#common-option-list">Common option list</a></li></ul></nav></header><section><header><h2 id="exit-codes"><a href="#exit-codes" class="anchor"></a>Exit codes</h2></header><dl><dt class="spec value" id="val-exits"><a href="#val-exits" class="anchor"></a><code><span class="keyword">val</span> exits : <span>Cmdliner.Term.exit_info list</span></code></dt><dd><p>Description of read-dwarf exit codes. May need to be updated</p></dd></dl></section><section><header><h2 id="config-options"><a href="#config-options" class="anchor"></a>Config options</h2><p>This section is to manage the configuration file. See <a href="../File/index.html"><code>Config.File</code></a> to see how the configuration file works</p></header><aside><p>Passing <code>--config=FILE</code> on the CLI will setup the <a href="../File/index.html"><code>Config.File</code></a> module to load that file as the configuration file.</p><p>For test executables, you will have to call <a href="../File/index.html#val-ensure_loaded"><code>File.ensure_loaded</code></a> directly.</p></aside><dl><dt class="spec value" id="val-config"><a href="#val-config" class="anchor"></a><code><span class="keyword">val</span> config : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-arch_val"><a href="#val-arch_val" class="anchor"></a><code><span class="keyword">val</span> arch_val : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><a href="../Arch/index.html#type-t">Arch.t</a> option</span> <span>&#45;&gt;</span> <a href="../Arch/index.html#type-t">Arch.t</a></code></dt><dt class="spec value" id="val-arch_opt"><a href="#val-arch_opt" class="anchor"></a><code><span class="keyword">val</span> arch_opt : <span><span><a href="../Arch/index.html#type-t">Arch.t</a> option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-arch"><a href="#val-arch" class="anchor"></a><code><span class="keyword">val</span> arch : <span><a href="../Arch/index.html#type-t">Arch.t</a> Cmdliner.Term.t</span></code></dt></dl></section><section><header><h2 id="isla-options"><a href="#isla-options" class="anchor"></a>Isla options</h2></header><dl><dt class="spec value" id="val-isla_client_ref"><a href="#val-isla_client_ref" class="anchor"></a><code><span class="keyword">val</span> isla_client_ref : <span>string Stdlib.ref</span></code></dt><dd><p>The isla_client path</p></dd></dl><dl><dt class="spec value" id="val-isla_client"><a href="#val-isla_client" class="anchor"></a><code><span class="keyword">val</span> isla_client : <span>unit Cmdliner.Term.t</span></code></dt></dl></section><section><header><h2 id="z3-options"><a href="#z3-options" class="anchor"></a>Z3 options</h2></header><dl><dt class="spec value" id="val-z3_ref"><a href="#val-z3_ref" class="anchor"></a><code><span class="keyword">val</span> z3_ref : <span>string Stdlib.ref</span></code></dt><dd><p>The z3 command</p></dd></dl><dl><dt class="spec value" id="val-z3"><a href="#val-z3" class="anchor"></a><code><span class="keyword">val</span> z3 : <span>unit Cmdliner.Term.t</span></code></dt><dd><p>The z3 option</p></dd></dl></section><section><header><h2 id="common-option-list"><a href="#common-option-list" class="anchor"></a>Common option list</h2></header><dl><dt class="spec value" id="val-comopts"><a href="#val-comopts" class="anchor"></a><code><span class="keyword">val</span> comopts : <span><span>unit Cmdliner.Term.t</span> list</span></code></dt><dd><p>The list of common options. Almost all sub-commands should use this.</p></dd></dl><dl><dt class="spec value" id="val-quick_exe"><a href="#val-quick_exe" class="anchor"></a><code><span class="keyword">val</span> quick_exe : <span>name:string</span> <span>&#45;&gt;</span> <span>doc:string</span> <span>&#45;&gt;</span> <span>(unit <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> unit</code></dt></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CommonOpt (read-dwarf.Config.CommonOpt)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; CommonOpt</nav><header class="odoc-preamble"><h1>Module <code><span>Config.CommonOpt</span></code></h1><p>This module provide support for common command line option to be used across multiple subcomands.</p><p>It also provide some <a href="../../Utils/index.html" title="Utils">utilities</a> on the command line.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#exit-codes">Exit codes</a></li><li><a href="#config-options">Config options</a></li><li><a href="#isla-options">Isla options</a></li><li><a href="#z3-options">Z3 options</a></li><li><a href="#common-option-list">Common option list</a></li></ul></nav></div><div class="odoc-content"><h2 id="exit-codes"><a href="#exit-codes" class="anchor"></a>Exit codes</h2><div class="odoc-spec"><div class="spec value anchored" id="val-exits"><a href="#val-exits" class="anchor"></a><code><span><span class="keyword">val</span> exits : <span><span class="xref-unresolved">Cmdliner</span>.Cmd.Exit.info list</span></span></code></div><div class="spec-doc"><p>Description of read-dwarf exit codes. May need to be updated</p></div></div><h2 id="config-options"><a href="#config-options" class="anchor"></a>Config options</h2><p>This section is to manage the configuration file. See <a href="../File/index.html"><code>Config.File</code></a> to see how the configuration file works</p><p>Passing <code>--config=FILE</code> on the CLI will setup the <a href="../File/index.html"><code>Config.File</code></a> module to load that file as the configuration file.</p><p>For test executables, you will have to call <a href="../File/index.html#val-ensure_loaded"><code>File.ensure_loaded</code></a> directly.</p><div class="odoc-spec"><div class="spec value anchored" id="val-config"><a href="#val-config" class="anchor"></a><code><span><span class="keyword">val</span> config : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arch_val"><a href="#val-arch_val" class="anchor"></a><code><span><span class="keyword">val</span> arch_val : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="../Arch/index.html#type-t">Arch.t</a> option</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Arch/index.html#type-t">Arch.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arch_opt"><a href="#val-arch_opt" class="anchor"></a><code><span><span class="keyword">val</span> arch_opt : <span><span><a href="../Arch/index.html#type-t">Arch.t</a> option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arch"><a href="#val-arch" class="anchor"></a><code><span><span class="keyword">val</span> arch : <span><a href="../Arch/index.html#type-t">Arch.t</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><h2 id="isla-options"><a href="#isla-options" class="anchor"></a>Isla options</h2><div class="odoc-spec"><div class="spec value anchored" id="val-isla_client_ref"><a href="#val-isla_client_ref" class="anchor"></a><code><span><span class="keyword">val</span> isla_client_ref : <span>string <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>The isla_client path</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_client"><a href="#val-isla_client" class="anchor"></a><code><span><span class="keyword">val</span> isla_client : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><h2 id="z3-options"><a href="#z3-options" class="anchor"></a>Z3 options</h2><div class="odoc-spec"><div class="spec value anchored" id="val-z3_ref"><a href="#val-z3_ref" class="anchor"></a><code><span><span class="keyword">val</span> z3_ref : <span>string <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>The z3 command</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-z3"><a href="#val-z3" class="anchor"></a><code><span><span class="keyword">val</span> z3 : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div><div class="spec-doc"><p>The z3 option</p></div></div><h2 id="common-option-list"><a href="#common-option-list" class="anchor"></a>Common option list</h2><div class="odoc-spec"><div class="spec value anchored" id="val-comopts"><a href="#val-comopts" class="anchor"></a><code><span><span class="keyword">val</span> comopts : <span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> list</span></span></code></div><div class="spec-doc"><p>The list of common options. Almost all sub-commands should use this.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command_tuple_to_cmd_t"><a href="#val-command_tuple_to_cmd_t" class="anchor"></a><code><span><span class="keyword">val</span> command_tuple_to_cmd_t : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Cmd.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-grouped_exe"><a href="#val-grouped_exe" class="anchor"></a><code><span><span class="keyword">val</span> grouped_exe : 
+  <span><span><span>(<span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-quick_exe"><a href="#val-quick_exe" class="anchor"></a><code><span><span class="keyword">val</span> quick_exe : <span><span class="label">name</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="label">doc</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/File/ArchConf/Isla/index.html b/doc/html/read-dwarf/Config/File/ArchConf/Isla/index.html
index bd3bbda9..20066ba3 100644
--- a/doc/html/read-dwarf/Config/File/ArchConf/Isla/index.html
+++ b/doc/html/read-dwarf/Config/File/ArchConf/Isla/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Isla (read-dwarf.Config.File.ArchConf.Isla)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Config</a> &#x00BB; <a href="../../index.html">File</a> &#x00BB; <a href="../index.html">ArchConf</a> &#x00BB; Isla</nav><h1>Module <code>ArchConf.Isla</code></h1><p>This module provides the current isla configuration.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.ignored_regs" class="anchored"><td class="def field"><a href="#type-t.ignored_regs" class="anchor"></a><code>ignored_regs : <span>string list</span>;</code></td><td class="doc"><p>The list of register to be ignored</p></td></tr><tr id="type-t.arch_file" class="anchored"><td class="def field"><a href="#type-t.arch_file" class="anchor"></a><code>arch_file : string;</code></td><td class="doc"><p>The name of the architecture.ir file to use. This is the file that was compiled with <code>isla-sail</code> from the sail source. Alternatively this file can be found in the <a href="https://github.com/rems-project/isla-snapshots"><code>isla-snapshots</code></a> respository.</p></td></tr><tr id="type-t.arch_toml" class="anchored"><td class="def field"><a href="#type-t.arch_toml" class="anchor"></a><code>arch_toml : string;</code></td><td class="doc"><p>The name of the architecture.toml file to use with Isla.</p></td></tr><tr id="type-t.arch_file_digest" class="anchored"><td class="def field"><a href="#type-t.arch_file_digest" class="anchor"></a><code>arch_file_digest : string;</code></td><td class="doc"><p>The digest of the file in <a href="index.html#type-t.arch_file"><code>arch_file</code></a>. This will be used instead of <a href="index.html#type-t.arch_file"><code>arch_file</code></a> by <a href="index.html#val-digest"><code>digest</code></a>.</p></td></tr><tr id="type-t.linearize" class="anchored"><td class="def field"><a href="#type-t.linearize" class="anchor"></a><code>linearize : <span>string list</span>;</code></td><td class="doc"><p>List of sail function to be linearized. That means that if there is a control-flow branching in that function, instead of generating multiple traces, isla will generate a single trace with it-then-else expression</p></td></tr><tr id="type-t.other_opts" class="anchored"><td class="def field"><a href="#type-t.other_opts" class="anchor"></a><code>other_opts : <span>string list</span>;</code></td><td class="doc"><p>List of other option to pass to isla. Ideally if an option is to be easily used, a new field of <a href="index.html#type-t"><code>t</code></a> should be created, but for quick and dirty testing, this field can be used.</p></td></tr></table><code>}</code></dt><dd><p>Isla configuration option. Everything in here is salient for cache coherency which means that if any option if changed here, the whole <span class="xref-unresolved" title="unresolved reference to &quot;Isla.Cache&quot;"><a href="../index.html#module-Isla"><code>Isla</code></a>.Cache</span> is invalidated. This is checked with <a href="index.html#val-digest"><code>digest</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-digest"><a href="#val-digest" class="anchor"></a><code><span class="keyword">val</span> digest : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Produces a digest of the Isla configuration for invalidating the <span class="xref-unresolved" title="unresolved reference to &quot;Isla.Cache&quot;"><a href="../index.html#module-Isla"><code>Isla</code></a>.Cache</span> when some configuration parameter changes</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Isla (read-dwarf.Config.File.ArchConf.Isla)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Config</a> &#x00BB; <a href="../../index.html">File</a> &#x00BB; <a href="../index.html">ArchConf</a> &#x00BB; Isla</nav><header class="odoc-preamble"><h1>Module <code><span>ArchConf.Isla</span></code></h1><p>This module provides the current isla configuration.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.ignored_regs" class="def record field anchored"><a href="#type-t.ignored_regs" class="anchor"></a><code><span>ignored_regs : <span>string list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The list of register to be ignored</p><span class="comment-delim">*)</span></div></li><li id="type-t.arch_file" class="def record field anchored"><a href="#type-t.arch_file" class="anchor"></a><code><span>arch_file : string;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The name of the architecture.ir file to use. This is the file that was compiled with <code>isla-sail</code> from the sail source. Alternatively this file can be found in the <a href="https://github.com/rems-project/isla-snapshots"><code>isla-snapshots</code></a> respository.</p><span class="comment-delim">*)</span></div></li><li id="type-t.arch_toml" class="def record field anchored"><a href="#type-t.arch_toml" class="anchor"></a><code><span>arch_toml : string;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The name of the architecture.toml file to use with Isla.</p><span class="comment-delim">*)</span></div></li><li id="type-t.arch_file_digest" class="def record field anchored"><a href="#type-t.arch_file_digest" class="anchor"></a><code><span>arch_file_digest : string;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The digest of the file in <a href="#type-t.arch_file"><code>arch_file</code></a>. This will be used instead of <a href="#type-t.arch_file"><code>arch_file</code></a> by <a href="#val-digest"><code>digest</code></a>.</p><span class="comment-delim">*)</span></div></li><li id="type-t.linearize" class="def record field anchored"><a href="#type-t.linearize" class="anchor"></a><code><span>linearize : <span>string list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>List of sail function to be linearized. That means that if there is a control-flow branching in that function, instead of generating multiple traces, isla will generate a single trace with it-then-else expression</p><span class="comment-delim">*)</span></div></li><li id="type-t.other_opts" class="def record field anchored"><a href="#type-t.other_opts" class="anchor"></a><code><span>other_opts : <span>string list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>List of other option to pass to isla. Ideally if an option is to be easily used, a new field of <a href="#type-t"><code>t</code></a> should be created, but for quick and dirty testing, this field can be used.</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Isla configuration option. Everything in here is salient for cache coherency which means that if any option if changed here, the whole <code>Isla.Cache</code> is invalidated. This is checked with <a href="#val-digest"><code>digest</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-digest"><a href="#val-digest" class="anchor"></a><code><span><span class="keyword">val</span> digest : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Produces a digest of the Isla configuration for invalidating the <code>Isla.Cache</code> when some configuration parameter changes</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/File/ArchConf/index.html b/doc/html/read-dwarf/Config/File/ArchConf/index.html
index df2522cf..e2430c93 100644
--- a/doc/html/read-dwarf/Config/File/ArchConf/index.html
+++ b/doc/html/read-dwarf/Config/File/ArchConf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ArchConf (read-dwarf.Config.File.ArchConf)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Config</a> &#x00BB; <a href="../index.html">File</a> &#x00BB; ArchConf</nav><h1>Module <code>File.ArchConf</code></h1></header><dl><dt class="spec module" id="module-Isla"><a href="#module-Isla" class="anchor"></a><code><span class="keyword">module</span> <a href="Isla/index.html">Isla</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provides the current isla configuration.</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.arch" class="anchored"><td class="def field"><a href="#type-t.arch" class="anchor"></a><code>arch : <a href="../../Arch/index.html#type-t">Arch.t</a>;</code></td><td class="doc"><p>The architecture targeted by this record</p></td></tr><tr id="type-t.toolchain" class="anchored"><td class="def field"><a href="#type-t.toolchain" class="anchor"></a><code>toolchain : string;</code></td><td class="doc"><p>The toolchain prefix for using this architecture with GNU binutils like <code>objdump</code> and <code>as</code>.</p></td></tr><tr id="type-t.isla" class="anchored"><td class="def field"><a href="#type-t.isla" class="anchor"></a><code>isla : <a href="Isla/index.html#type-t">Isla.t</a>;</code></td><td class="doc"><p>The isla configuration for this architecture</p></td></tr></table><code>}</code></dt><dd><p>The list of all architecture specific configuration options</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ArchConf (read-dwarf.Config.File.ArchConf)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Config</a> &#x00BB; <a href="../index.html">File</a> &#x00BB; ArchConf</nav><header class="odoc-preamble"><h1>Module <code><span>File.ArchConf</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Isla"><a href="#module-Isla" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Isla/index.html">Isla</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides the current isla configuration.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.arch" class="def record field anchored"><a href="#type-t.arch" class="anchor"></a><code><span>arch : <a href="../../Arch/index.html#type-t">Arch.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The architecture targeted by this record</p><span class="comment-delim">*)</span></div></li><li id="type-t.toolchain" class="def record field anchored"><a href="#type-t.toolchain" class="anchor"></a><code><span>toolchain : string;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The toolchain prefix for using this architecture with GNU binutils like <code>objdump</code> and <code>as</code>.</p><span class="comment-delim">*)</span></div></li><li id="type-t.isla" class="def record field anchored"><a href="#type-t.isla" class="anchor"></a><code><span>isla : <a href="Isla/index.html#type-t">Isla.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The isla configuration for this architecture</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The list of all architecture specific configuration options</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/File/Z3/index.html b/doc/html/read-dwarf/Config/File/Z3/index.html
index 3c59d8b7..c00dada2 100644
--- a/doc/html/read-dwarf/Config/File/Z3/index.html
+++ b/doc/html/read-dwarf/Config/File/Z3/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3 (read-dwarf.Config.File.Z3)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Config</a> &#x00BB; <a href="../index.html">File</a> &#x00BB; Z3</nav><h1>Module <code>File.Z3</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.timeout" class="anchored"><td class="def field"><a href="#type-t.timeout" class="anchor"></a><code>timeout : <span>int option</span>;</code></td><td class="doc"><p>Timeout for individual requests in milliseconds</p></td></tr><tr id="type-t.memory" class="anchored"><td class="def field"><a href="#type-t.memory" class="anchor"></a><code>memory : <span>int option</span>;</code></td><td class="doc"><p>Maximum memory, in MegaBytes</p></td></tr><tr id="type-t.simplify_opts" class="anchored"><td class="def field"><a href="#type-t.simplify_opts" class="anchor"></a><code>simplify_opts : <span><span>(string * bool)</span> list</span>;</code></td><td class="doc"><p>List of option for the simplify command</p></td></tr></table><code>}</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3 (read-dwarf.Config.File.Z3)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Config</a> &#x00BB; <a href="../index.html">File</a> &#x00BB; Z3</nav><header class="odoc-preamble"><h1>Module <code><span>File.Z3</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.timeout" class="def record field anchored"><a href="#type-t.timeout" class="anchor"></a><code><span>timeout : <span>int option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Timeout for individual requests in milliseconds</p><span class="comment-delim">*)</span></div></li><li id="type-t.memory" class="def record field anchored"><a href="#type-t.memory" class="anchor"></a><code><span>memory : <span>int option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Maximum memory, in MegaBytes</p><span class="comment-delim">*)</span></div></li><li id="type-t.simplify_opts" class="def record field anchored"><a href="#type-t.simplify_opts" class="anchor"></a><code><span>simplify_opts : <span><span>(string * bool)</span> list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>List of option for the simplify command</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/File/index.html b/doc/html/read-dwarf/Config/File/index.html
index 87ced6a2..330a91ff 100644
--- a/doc/html/read-dwarf/Config/File/index.html
+++ b/doc/html/read-dwarf/Config/File/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>File (read-dwarf.Config.File)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; File</nav><h1>Module <code>Config.File</code></h1><p>This module is to handle the configuration file of the program.</p><p>For now I expect a TOML format and use the <code>toml</code> library from opam. The data structure themselves are format agnostic so if we change the TOML library of change of format, only this file must be modified. For example to JSON or YAML.</p><p>The top level usage is to first set the <code>file</code> reference which will be done by <a href="../CommonOpt/index.html#val-config"><code>CommonOpt.config</code></a> using <a href="index.html#val-ensure_loaded"><code>ensure_loaded</code></a>. Then the config can be accessed with the various <a href="index.html#acc"><span>Accessors</span></a></p><nav class="toc"><ul><li><a href="#configuration-structure">Configuration structure</a></li><li><a href="#file-loading">File loading</a></li><li><a href="#acc">Accessors</a></li></ul></nav></header><section><header><h2 id="configuration-structure"><a href="#configuration-structure" class="anchor"></a>Configuration structure</h2><p>All field of records in this section have a matching line in the checked-in <code>config.toml</code>. If something is optional here, and should be disabled in the default <code>config.toml</code>, put a commented line there, so that the correspondence can be immediately seen.</p></header><div class="spec module" id="module-ArchConf"><a href="#module-ArchConf" class="anchor"></a><code><span class="keyword">module</span> <a href="ArchConf/index.html">ArchConf</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Z3"><a href="#module-Z3" class="anchor"></a><code><span class="keyword">module</span> <a href="Z3/index.html">Z3</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-archs_type"><a href="#type-archs_type" class="anchor"></a><code><span class="keyword">type</span> archs_type</code><code> = <span><span>(<a href="../Arch/index.html#type-t">Arch.t</a>, <a href="ArchConf/index.html#type-t">ArchConf.t</a>)</span> Stdlib.Hashtbl.t</span></code></dt><dd><p>Each architecture specific configuration is specified by a TOML section represented by a <a href="../Arch/index.html#type-t"><code>Arch.t</code></a> record. They are stored in this type</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.arch" class="anchored"><td class="def field"><a href="#type-t.arch" class="anchor"></a><code>arch : <span><a href="../Arch/index.html#type-t">Arch.t</a> option</span>;</code></td><td class="doc"><p>The default architecture to be choosen when no ELF file is specified on the CLI. This is optional, but if supplied, it will override <a href="../index.html#val-arch"><code>Config.arch</code></a></p></td></tr><tr id="type-t.archs" class="anchored"><td class="def field"><a href="#type-t.archs" class="anchor"></a><code>archs : <a href="index.html#type-archs_type">archs_type</a>;</code></td><td class="doc"><p>All the architecture specific configurations</p></td></tr><tr id="type-t.z3" class="anchored"><td class="def field"><a href="#type-t.z3" class="anchor"></a><code>z3 : <a href="Z3/index.html#type-t">Z3.t</a>;</code></td><td class="doc"><p>The Z3 configuration</p></td></tr></table><code>}</code></dt></dl></section><section><header><h2 id="file-loading"><a href="#file-loading" class="anchor"></a>File loading</h2><p>This section is about loading the configuration from a TOML file</p></header><dl><dt class="spec value" id="val-load"><a href="#val-load" class="anchor"></a><code><span class="keyword">val</span> load : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Load the configuration file from the specified file name</p></dd></dl><dl><dt class="spec value" id="val-ensure_loaded"><a href="#val-ensure_loaded" class="anchor"></a><code><span class="keyword">val</span> ensure_loaded : string <span>&#45;&gt;</span> unit</code></dt><dd><p>If the configuration file is not already loaded, load it from the specified file.</p></dd></dl></section><section><header><h2 id="acc"><a href="#acc" class="anchor"></a>Accessors</h2><p>The section provide various accessor to access directly part of the configuration</p><p>The config must be loaded otherwise <a href="index.html#exception-UnloadedConfig"><code>UnloadedConfig</code></a> will be thrown</p></header><dl><dt class="spec exception" id="exception-UnloadedConfig"><a href="#exception-UnloadedConfig" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">UnloadedConfig</span></code></dt><dd><p>This exception will be raised if any of the accessor is called while the config is not loaded.</p></dd></dl><dl><dt class="spec value" id="val-get_config"><a href="#val-get_config" class="anchor"></a><code><span class="keyword">val</span> get_config : unit <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get all the configuration information</p></dd></dl><dl><dt class="spec value" id="val-get_arch_name"><a href="#val-get_arch_name" class="anchor"></a><code><span class="keyword">val</span> get_arch_name : unit <span>&#45;&gt;</span> <a href="../Arch/index.html#type-t">Arch.t</a></code></dt><dd><p>Get the default architecture name to be used if no architecture is implicitly or explicitly specified on the CLI</p></dd></dl><dl><dt class="spec value" id="val-get_arch_config"><a href="#val-get_arch_config" class="anchor"></a><code><span class="keyword">val</span> get_arch_config : <a href="../Arch/index.html#type-t">Arch.t</a> <span>&#45;&gt;</span> <a href="ArchConf/index.html#type-t">ArchConf.t</a></code></dt><dd><p>Get the architecture configuration for a specific architecture. To get the architecture configuration of the currently enabled architecture, Call <span class="xref-unresolved" title="unresolved reference to &quot;Arch.get_config&quot;"><a href="../index.html#module-Arch"><code>Arch</code></a>.get_config</span></p></dd></dl><dl><dt class="spec value" id="val-get_isla_config"><a href="#val-get_isla_config" class="anchor"></a><code><span class="keyword">val</span> get_isla_config : <a href="../Arch/index.html#type-t">Arch.t</a> <span>&#45;&gt;</span> <a href="ArchConf/Isla/index.html#type-t">ArchConf.Isla.t</a></code></dt><dd><p>Get the isla configuration for a specific architecture. To get the isla configuration of the currently enabled architecture, Call <span class="xref-unresolved" title="unresolved reference to &quot;Arch.get_isla_config&quot;"><a href="../index.html#module-Arch"><code>Arch</code></a>.get_isla_config</span></p></dd></dl><dl><dt class="spec value" id="val-get_z3_config"><a href="#val-get_z3_config" class="anchor"></a><code><span class="keyword">val</span> get_z3_config : unit <span>&#45;&gt;</span> <a href="Z3/index.html#type-t">Z3.t</a></code></dt><dd><p>Get the Z3 configuration</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>File (read-dwarf.Config.File)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; File</nav><header class="odoc-preamble"><h1>Module <code><span>Config.File</span></code></h1><p>This module is to handle the configuration file of the program.</p><p>For now I expect a TOML format and use the <code>toml</code> library from opam. The data structure themselves are format agnostic so if we change the TOML library of change of format, only this file must be modified. For example to JSON or YAML.</p><p>The top level usage is to first set the <code>file</code> reference which will be done by <a href="../CommonOpt/index.html#val-config"><code>CommonOpt.config</code></a> using <a href="#val-ensure_loaded"><code>ensure_loaded</code></a>. Then the config can be accessed with the various <a href="#acc" title="acc">Accessors</a></p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#configuration-structure">Configuration structure</a></li><li><a href="#file-loading">File loading</a></li><li><a href="#acc">Accessors</a></li></ul></nav></div><div class="odoc-content"><h2 id="configuration-structure"><a href="#configuration-structure" class="anchor"></a>Configuration structure</h2><p>All field of records in this section have a matching line in the checked-in <code>config.toml</code>. If something is optional here, and should be disabled in the default <code>config.toml</code>, put a commented line there, so that the correspondence can be immediately seen.</p><div class="odoc-spec"><div class="spec module anchored" id="module-ArchConf"><a href="#module-ArchConf" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ArchConf/index.html">ArchConf</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Z3"><a href="#module-Z3" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Z3/index.html">Z3</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-archs_type"><a href="#type-archs_type" class="anchor"></a><code><span><span class="keyword">type</span> archs_type</span><span> = <span><span>(<a href="../Arch/index.html#type-t">Arch.t</a>, <a href="ArchConf/index.html#type-t">ArchConf.t</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span></span></code></div><div class="spec-doc"><p>Each architecture specific configuration is specified by a TOML section represented by a <a href="../Arch/index.html#type-t"><code>Arch.t</code></a> record. They are stored in this type</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.arch" class="def record field anchored"><a href="#type-t.arch" class="anchor"></a><code><span>arch : <span><a href="../Arch/index.html#type-t">Arch.t</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The default architecture to be choosen when no ELF file is specified on the CLI. This is optional, but if supplied, it will override <a href="../index.html#val-arch"><code>Config.arch</code></a></p><span class="comment-delim">*)</span></div></li><li id="type-t.archs" class="def record field anchored"><a href="#type-t.archs" class="anchor"></a><code><span>archs : <a href="#type-archs_type">archs_type</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>All the architecture specific configurations</p><span class="comment-delim">*)</span></div></li><li id="type-t.z3" class="def record field anchored"><a href="#type-t.z3" class="anchor"></a><code><span>z3 : <a href="Z3/index.html#type-t">Z3.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The Z3 configuration</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div></div><h2 id="file-loading"><a href="#file-loading" class="anchor"></a>File loading</h2><p>This section is about loading the configuration from a TOML file</p><div class="odoc-spec"><div class="spec value anchored" id="val-load"><a href="#val-load" class="anchor"></a><code><span><span class="keyword">val</span> load : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Load the configuration file from the specified file name</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_loaded"><a href="#val-ensure_loaded" class="anchor"></a><code><span><span class="keyword">val</span> ensure_loaded : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>If the configuration file is not already loaded, load it from the specified file.</p></div></div><h2 id="acc"><a href="#acc" class="anchor"></a>Accessors</h2><p>The section provide various accessor to access directly part of the configuration</p><p>The config must be loaded otherwise <a href="#exception-UnloadedConfig"><code>UnloadedConfig</code></a> will be thrown</p><div class="odoc-spec"><div class="spec exception anchored" id="exception-UnloadedConfig"><a href="#exception-UnloadedConfig" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">UnloadedConfig</span></span></code></div><div class="spec-doc"><p>This exception will be raised if any of the accessor is called while the config is not loaded.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_config"><a href="#val-get_config" class="anchor"></a><code><span><span class="keyword">val</span> get_config : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get all the configuration information</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_arch_name"><a href="#val-get_arch_name" class="anchor"></a><code><span><span class="keyword">val</span> get_arch_name : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Arch/index.html#type-t">Arch.t</a></span></code></div><div class="spec-doc"><p>Get the default architecture name to be used if no architecture is implicitly or explicitly specified on the CLI</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_arch_config"><a href="#val-get_arch_config" class="anchor"></a><code><span><span class="keyword">val</span> get_arch_config : <span><a href="../Arch/index.html#type-t">Arch.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="ArchConf/index.html#type-t">ArchConf.t</a></span></code></div><div class="spec-doc"><p>Get the architecture configuration for a specific architecture. To get the architecture configuration of the currently enabled architecture, Call <code>Arch.get_config</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_isla_config"><a href="#val-get_isla_config" class="anchor"></a><code><span><span class="keyword">val</span> get_isla_config : <span><a href="../Arch/index.html#type-t">Arch.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="ArchConf/Isla/index.html#type-t">ArchConf.Isla.t</a></span></code></div><div class="spec-doc"><p>Get the isla configuration for a specific architecture. To get the isla configuration of the currently enabled architecture, Call <code>Arch.get_isla_config</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_z3_config"><a href="#val-get_z3_config" class="anchor"></a><code><span><span class="keyword">val</span> get_z3_config : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="Z3/index.html#type-t">Z3.t</a></span></code></div><div class="spec-doc"><p>Get the Z3 configuration</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/index.html b/doc/html/read-dwarf/Config/index.html
index 9cd46265..c245c5d6 100644
--- a/doc/html/read-dwarf/Config/index.html
+++ b/doc/html/read-dwarf/Config/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Config (read-dwarf.Config)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Config</nav><h1>Module <code>Config</code></h1></header><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="index.html#module-type-S">S</a></code></span></summary><dl><dt class="spec value" id="val-config_file"><a href="#val-config_file" class="anchor"></a><code><span class="keyword">val</span> config_file : string</code></dt><dd><p>Default config file</p></dd></dl><dl><dt class="spec value" id="val-z3"><a href="#val-z3" class="anchor"></a><code><span class="keyword">val</span> z3 : string</code></dt><dd><p>Default Z3 command. (Can be overidden with Z3_PATH and <code>--z3</code>)</p></dd></dl><dl><dt class="spec value" id="val-isla_client"><a href="#val-isla_client" class="anchor"></a><code><span class="keyword">val</span> isla_client : string</code></dt><dd><p>Default Isla command. (Can be overidden with ISLA_CLIENT and <code>--isla</code>)</p></dd></dl><dl><dt class="spec value" id="val-arch"><a href="#val-arch" class="anchor"></a><code><span class="keyword">val</span> arch : string</code></dt><dd><p>The default architecture to pick when none is specified</p></dd></dl><dl><dt class="spec value" id="val-enable_backtrace"><a href="#val-enable_backtrace" class="anchor"></a><code><span class="keyword">val</span> enable_backtrace : bool</code></dt><dd><p>Whether to enable backtraces or not</p></dd></dl><dl><dt class="spec value" id="val-enable_tests"><a href="#val-enable_tests" class="anchor"></a><code><span class="keyword">val</span> enable_tests : bool</code></dt><dd><p>Whether to enable internal unit test and the test test sub-command</p></dd></dl></details></div></div></div><dl><dt class="spec module" id="module-Arch"><a href="#module-Arch" class="anchor"></a><code><span class="keyword">module</span> <a href="Arch/index.html">Arch</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provides an enumeration of architecture for internal identification</p></dd></dl><dl><dt class="spec module" id="module-File"><a href="#module-File" class="anchor"></a><code><span class="keyword">module</span> <a href="File/index.html">File</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module is to handle the configuration file of the program.</p></dd></dl><dl><dt class="spec module" id="module-CommonOpt"><a href="#module-CommonOpt" class="anchor"></a><code><span class="keyword">module</span> <a href="CommonOpt/index.html">CommonOpt</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide support for common command line option to be used across multiple subcomands.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Config (read-dwarf.Config)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Config</nav><header class="odoc-preamble"><h1>Module <code><span>Config</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This is the compile-time configuration module. It is pulled from the root <code>config.ml</code> file or will fallback to the <code>default_config.ml</code> file</p></div></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="module-type-S/index.html">S</a></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-config_file"><a href="#val-config_file" class="anchor"></a><code><span><span class="keyword">val</span> config_file : string</span></code></div><div class="spec-doc"><p>Default config file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-z3"><a href="#val-z3" class="anchor"></a><code><span><span class="keyword">val</span> z3 : string</span></code></div><div class="spec-doc"><p>Default Z3 command. (Can be overidden with Z3_PATH and <code>--z3</code>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_client"><a href="#val-isla_client" class="anchor"></a><code><span><span class="keyword">val</span> isla_client : string</span></code></div><div class="spec-doc"><p>Default Isla command. (Can be overidden with ISLA_CLIENT and <code>--isla</code>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arch"><a href="#val-arch" class="anchor"></a><code><span><span class="keyword">val</span> arch : string</span></code></div><div class="spec-doc"><p>The default architecture to pick when none is specified</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enable_backtrace"><a href="#val-enable_backtrace" class="anchor"></a><code><span><span class="keyword">val</span> enable_backtrace : bool</span></code></div><div class="spec-doc"><p>Whether to enable backtraces or not</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enable_tests"><a href="#val-enable_tests" class="anchor"></a><code><span><span class="keyword">val</span> enable_tests : bool</span></code></div><div class="spec-doc"><p>Whether to enable internal unit test and the test test sub-command</p></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Arch"><a href="#module-Arch" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Arch/index.html">Arch</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides an enumeration of architecture for internal identification</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-File"><a href="#module-File" class="anchor"></a><code><span><span class="keyword">module</span> <a href="File/index.html">File</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is to handle the configuration file of the program.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-CommonOpt"><a href="#module-CommonOpt" class="anchor"></a><code><span><span class="keyword">module</span> <a href="CommonOpt/index.html">CommonOpt</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide support for common command line option to be used across multiple subcomands.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Config/module-type-S/index.html b/doc/html/read-dwarf/Config/module-type-S/index.html
index aff10564..7a6ba68b 100644
--- a/doc/html/read-dwarf/Config/module-type-S/index.html
+++ b/doc/html/read-dwarf/Config/module-type-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Config.S)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; S</nav><h1>Module type <code>Config.S</code></h1></header><aside><p>This is the compile-time configuration module. It is pulled from the root <code>config.ml</code> file or will fallback to the <code>default_config.ml</code> file</p><p>All compile-time configuration options are specified here. For runtime configuration, look at <a href="../File/index.html"><code>Config.File</code></a>.</p></aside><dl><dt class="spec value" id="val-config_file"><a href="#val-config_file" class="anchor"></a><code><span class="keyword">val</span> config_file : string</code></dt><dd><p>Default config file</p></dd></dl><dl><dt class="spec value" id="val-z3"><a href="#val-z3" class="anchor"></a><code><span class="keyword">val</span> z3 : string</code></dt><dd><p>Default Z3 command. (Can be overidden with Z3_PATH and <code>--z3</code>)</p></dd></dl><dl><dt class="spec value" id="val-isla_client"><a href="#val-isla_client" class="anchor"></a><code><span class="keyword">val</span> isla_client : string</code></dt><dd><p>Default Isla command. (Can be overidden with ISLA_CLIENT and <code>--isla</code>)</p></dd></dl><dl><dt class="spec value" id="val-arch"><a href="#val-arch" class="anchor"></a><code><span class="keyword">val</span> arch : string</code></dt><dd><p>The default architecture to pick when none is specified</p></dd></dl><dl><dt class="spec value" id="val-enable_backtrace"><a href="#val-enable_backtrace" class="anchor"></a><code><span class="keyword">val</span> enable_backtrace : bool</code></dt><dd><p>Whether to enable backtraces or not</p></dd></dl><dl><dt class="spec value" id="val-enable_tests"><a href="#val-enable_tests" class="anchor"></a><code><span class="keyword">val</span> enable_tests : bool</code></dt><dd><p>Whether to enable internal unit test and the test test sub-command</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Config.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Config</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Module type <code><span>Config.S</span></code></h1><p>This is the compile-time configuration module. It is pulled from the root <code>config.ml</code> file or will fallback to the <code>default_config.ml</code> file</p><p>All compile-time configuration options are specified here. For runtime configuration, look at <a href="../File/index.html"><code>Config.File</code></a>.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-config_file"><a href="#val-config_file" class="anchor"></a><code><span><span class="keyword">val</span> config_file : string</span></code></div><div class="spec-doc"><p>Default config file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-z3"><a href="#val-z3" class="anchor"></a><code><span><span class="keyword">val</span> z3 : string</span></code></div><div class="spec-doc"><p>Default Z3 command. (Can be overidden with Z3_PATH and <code>--z3</code>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_client"><a href="#val-isla_client" class="anchor"></a><code><span><span class="keyword">val</span> isla_client : string</span></code></div><div class="spec-doc"><p>Default Isla command. (Can be overidden with ISLA_CLIENT and <code>--isla</code>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arch"><a href="#val-arch" class="anchor"></a><code><span><span class="keyword">val</span> arch : string</span></code></div><div class="spec-doc"><p>The default architecture to pick when none is specified</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enable_backtrace"><a href="#val-enable_backtrace" class="anchor"></a><code><span><span class="keyword">val</span> enable_backtrace : bool</span></code></div><div class="spec-doc"><p>Whether to enable backtraces or not</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enable_tests"><a href="#val-enable_tests" class="anchor"></a><code><span><span class="keyword">val</span> enable_tests : bool</span></code></div><div class="spec-doc"><p>Whether to enable internal unit test and the test test sub-command</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Configuration.html b/doc/html/read-dwarf/Configuration.html
index 021f746d..44deee79 100644
--- a/doc/html/read-dwarf/Configuration.html
+++ b/doc/html/read-dwarf/Configuration.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Configuration (read-dwarf.Configuration)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; Configuration</nav><h1 id="configuration"><a href="#configuration" class="anchor"></a>Configuration</h1><nav class="toc"><ul><li><a href="#compile-time-configuration">Compile time configuration</a></li><li><a href="#runtime-configuration">Runtime configuration</a></li></ul></nav></header><h2 id="compile-time-configuration"><a href="#compile-time-configuration" class="anchor"></a>Compile time configuration</h2><p>Currently, read-dwarf only supports compile-time (not run-time) selection of architecture, through <a href="https://dune.readthedocs.io/en/stable/variants.html">Dune's virtual modules</a>. See <a href="Architecture.html"><code>Architecture</code></a> for more details.</p><p>Other compile-time configuration options can be edited in the file <code>src/confing/default.ml</code>, and accessed in the rest of the code through the <a href="Config/index.html"><code>Config</code></a> module.</p><h2 id="runtime-configuration"><a href="#runtime-configuration" class="anchor"></a>Runtime configuration</h2><p>Runtime configuration is loaded from toml file at runtime and handled by the <a href="Config/File/index.html"><code>Config.File</code></a> module. The location of the file (and the side effect of loading) is determined by the <a href="Config__/CommonOpt/index.html#val-config"><code>Config.CommonOpt.config</code></a> option. The various fields can then be accessed by <a href="Config__/File/index.html#acc"><span>Accessors</span></a>.</p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Configuration (read-dwarf.Configuration)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; Configuration</nav><header class="odoc-preamble"><h1 id="configuration"><a href="#configuration" class="anchor"></a>Configuration</h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#compile-time-configuration">Compile time configuration</a></li><li><a href="#runtime-configuration">Runtime configuration</a></li></ul></nav></div><div class="odoc-content"><h2 id="compile-time-configuration"><a href="#compile-time-configuration" class="anchor"></a>Compile time configuration</h2><p>Currently, read-dwarf only supports compile-time (not run-time) selection of architecture, through <a href="https://dune.readthedocs.io/en/stable/variants.html">Dune's virtual modules</a>. See <a href="Architecture.html"><code>Architecture</code></a> for more details.</p><p>Other compile-time configuration options can be edited in the file <code>src/confing/default.ml</code>, and accessed in the rest of the code through the <a href="Config/index.html"><code>Config</code></a> module.</p><h2 id="runtime-configuration"><a href="#runtime-configuration" class="anchor"></a>Runtime configuration</h2><p>Runtime configuration is loaded from toml file at runtime and handled by the <a href="Config/File/index.html"><code>Config.File</code></a> module. The location of the file (and the side effect of loading) is determined by the <a href="Config/CommonOpt/index.html#val-config"><code>Config.CommonOpt.config</code></a> option. The various fields can then be accessed by <a href="Config/File/index.html#acc" title="acc">Accessors</a>.</p></div></body></html>
diff --git a/doc/html/read-dwarf/Ctype/FieldMap/index.html b/doc/html/read-dwarf/Ctype/FieldMap/index.html
index 292c64a9..316e9ba1 100644
--- a/doc/html/read-dwarf/Ctype/FieldMap/index.html
+++ b/doc/html/read-dwarf/Ctype/FieldMap/index.html
@@ -1,6 +1,11 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>FieldMap (read-dwarf.Ctype.FieldMap)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Ctype</a> &#x00BB; FieldMap</nav><h1>Module <code>Ctype.FieldMap</code></h1><p>A range map over field to represent a structure layout</p></header><dl><dt class="spec type" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span class="keyword">type</span> obj</code><code> = <a href="../index.html#type-field">field</a></code></dt><dd><p>The type of the contained object</p></dd></dl><dl><dt class="spec type" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span class="keyword">type</span> obj_off</code><code> = <a href="index.html#type-obj">obj</a> * int</code></dt><dd><p>The type of an object with an offset</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of the map from address ranges to <a href="index.html#type-obj"><code>obj</code></a></p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>An empty <code>RngMap</code></p></dd></dl><dl><dt class="spec value" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span class="keyword">val</span> is_in : <span>objaddr:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Test if an address is inside the object at address <code>objaddr</code></p></dd></dl><dl><dt class="spec value" id="val-at"><a href="#val-at" class="anchor"></a><code><span class="keyword">val</span> at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a></code></dt><dd><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span class="keyword">val</span> at_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj">obj</a> option</span></code></dt><dd><p>Get the object containing the address. <code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span class="keyword">val</span> at_off : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object</p><pre><code class="ml">at_off map addr = (obj, off) </code></pre><p>means:</p><pre>         |                      |           |         |
-       map 0                 obj start    point    obj end
-         |&lt;--------------addr--------------&gt;|
-                                |&lt;---off---&gt;|
-                                |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span class="keyword">val</span> at_off_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj_off">obj_off</a> option</span></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object. See <a href="index.html#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-update"><a href="#val-update" class="anchor"></a><code><span class="keyword">val</span> update : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></dd></dl><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span class="keyword">val</span> clear_at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear the object containing the address if any</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="index.html#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="index.html#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></dd></dl><dl><dt class="spec value" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span class="keyword">val</span> clear_crop : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span>crop:<span>(<span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></dd></dl><dl><dt class="spec value" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span class="keyword">val</span> clear_bounds : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="index.html#val-empty"><code>empty</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span class="keyword">val</span> addp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> list</span></code></dt><dd><p>Give the list of bindings</p></dd></dl><dl><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> <a href="../../Utils/index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dd><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>FieldMap (read-dwarf.Ctype.FieldMap)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Ctype</a> &#x00BB; FieldMap</nav><header class="odoc-preamble"><h1>Module <code><span>Ctype.FieldMap</span></code></h1><p>A range map over field to represent a structure layout</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span><span class="keyword">type</span> obj</span><span> = <a href="../index.html#type-field">field</a></span></code></div><div class="spec-doc"><p>The type of the contained object</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span><span class="keyword">type</span> obj_off</span><span> = <a href="#type-obj">obj</a> * int</span></code></div><div class="spec-doc"><p>The type of an object with an offset</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of the map from address ranges to <a href="#type-obj"><code>obj</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>An empty <code>RngMap</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span><span class="keyword">val</span> is_in : <span><span class="label">objaddr</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test if an address is inside the object at address <code>objaddr</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at"><a href="#val-at" class="anchor"></a><code><span><span class="keyword">val</span> at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a></span></code></div><div class="spec-doc"><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address. <code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span><span class="keyword">val</span> at_off : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj_off">obj_off</a></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object</p><pre class="language-ocaml"><code>at_off map addr = (obj, off) </code></pre><p>means:</p><pre>   |                      |           |         |
+ map 0                 obj start    point    obj end
+   |&lt;--------------addr--------------&gt;|
+                          |&lt;---off---&gt;|
+                          |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_off_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object. See <a href="#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span><span class="keyword">val</span> clear_at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear the object containing the address if any</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span><span class="keyword">val</span> clear_crop : 
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">crop</span>:<span>(<span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span><span class="keyword">val</span> clear_bounds : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="#val-empty"><code>empty</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span><span class="keyword">val</span> addp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="#type-obj">obj</a>)</span> list</span></span></code></div><div class="spec-doc"><p>Give the list of bindings</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="#type-obj">obj</a>)</span> <a href="../../Utils/Seq/index.html#type-t">Utils.Seq.t</a></span></span></code></div><div class="spec-doc"><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Ctype/index.html b/doc/html/read-dwarf/Ctype/index.html
index 9bd6d26b..cb071f7c 100644
--- a/doc/html/read-dwarf/Ctype/index.html
+++ b/doc/html/read-dwarf/Ctype/index.html
@@ -1,2 +1,64 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Ctype (read-dwarf.Ctype)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Ctype</nav><h1>Module <code>Ctype</code></h1><p>This module provides the internal C-like type system. This type system is slightly different than the normal C type system. This module only provides the Ocaml datastructure to represent those types. The typing rules are implemented in <span class="xref-unresolved" title="unresolved reference to &quot;Trace.Typer&quot;"><a href="../Trace/index.html"><code>Trace</code></a>.Typer</span>, where they are applied dire</p><p>These types follow the normal C type structure except for pointers that are more complex. To handle the fact that the C compiler knows perfectly the ABI and is &quot;allowed&quot; to used it, we have to make pointer types resist manual adjusting of pointers to point to the field of a struct. However the new pointer cannot just have type <code>field_type*</code> because one could want to get back a pointer to the whole structure by subtracting an offset from the field pointer. Thus a pointer must never forget information about its surroundings. Those surroundings are called a <a href="index.html#type-fragment"><code>fragment</code></a> and represent all the type information of the fragment of memory in which a pointer lies. The pointer is thus represented as a fragment of memory and an offset. Since the pointer type is more complex and packs more information, the surface syntax has changed. A pointer type is written between braces, so <code>A*</code> becomes <code>{A}</code>, but in more complex cases, all informations fit between the braces.</p><p>Furthermore, the fragment part of the pointer does not record any information about aliasing: two different type fragments are perfectly allowed to alias. To handle non-aliasing properties, like the stack not aliasing the heap or restrict pointers, pointers also have a <code>provenance</code> field. See <a href="../State/Mem/index.html"><code>State.Mem</code></a>.</p><p>There is another problem: The C language does not define a C type system for the whole program, contrary to C++. It defines only a type system per compilation unit. This limitation is too annoying to work with so the module implements some kind of linking of types, similar to C++ rules. See <a href="index.html#ctyplink"><span>C type linking: From Linksem</span></a>.</p><nav class="toc"><ul><li><a href="#dwarf-constants">DWARF constants</a></li><li><a href="#types">Types</a></li><li><a href="#comparisons">Comparisons</a></li><li><a href="#convenience-manipulation">Convenience manipulation</a></li><li><a href="#sizeof">Sizeof</a></li><li><a href="#ctyplink">C type linking: From Linksem</a></li><li><a href="#pretty-printing">Pretty printing</a></li><li><a href="#type-at">Type at</a></li></ul></nav></header><section><header><h2 id="dwarf-constants"><a href="#dwarf-constants" class="anchor"></a>DWARF constants</h2></header><dl><dt class="spec value" id="val-vDW_ATE_address"><a href="#val-vDW_ATE_address" class="anchor"></a><code><span class="keyword">val</span> vDW_ATE_address : int</code></dt><dt class="spec value" id="val-vDW_ATE_boolean"><a href="#val-vDW_ATE_boolean" class="anchor"></a><code><span class="keyword">val</span> vDW_ATE_boolean : int</code></dt><dt class="spec value" id="val-vDW_ATE_signed"><a href="#val-vDW_ATE_signed" class="anchor"></a><code><span class="keyword">val</span> vDW_ATE_signed : int</code></dt><dt class="spec value" id="val-vDW_ATE_signed_char"><a href="#val-vDW_ATE_signed_char" class="anchor"></a><code><span class="keyword">val</span> vDW_ATE_signed_char : int</code></dt><dt class="spec value" id="val-vDW_ATE_unsigned"><a href="#val-vDW_ATE_unsigned" class="anchor"></a><code><span class="keyword">val</span> vDW_ATE_unsigned : int</code></dt><dt class="spec value" id="val-vDW_ATE_unsigned_char"><a href="#val-vDW_ATE_unsigned_char" class="anchor"></a><code><span class="keyword">val</span> vDW_ATE_unsigned_char : int</code></dt></dl></section><section><header><h2 id="types"><a href="#types" class="anchor"></a>Types</h2></header><dl><dt class="spec type" id="type-provenance"><a href="#type-provenance" class="anchor"></a><code><span class="keyword">type</span> provenance</code><code> = </code><table class="variant"><tr id="type-provenance.Restricted" class="anchored"><td class="def constructor"><a href="#type-provenance.Restricted" class="anchor"></a><code>| </code><code><span class="constructor">Restricted</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-provenance.Main" class="anchored"><td class="def constructor"><a href="#type-provenance.Main" class="anchor"></a><code>| </code><code><span class="constructor">Main</span></code></td></tr></table></dt><dd><p>This is the provenance of the pointer. This tells to which symbolic memory block a pointer points to. To get the full explanation, go to <a href="../State/Mem/index.html"><code>State.Mem</code></a></p></dd></dl><dl><dt class="spec value" id="val-pp_provenance"><a href="#val-pp_provenance" class="anchor"></a><code><span class="keyword">val</span> pp_provenance : <a href="index.html#type-provenance">provenance</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt></dl><dl><dt class="spec type" id="type-unqualified"><a href="#type-unqualified" class="anchor"></a><code><span class="keyword">type</span> unqualified</code><code> = </code><table class="variant"><tr id="type-unqualified.Machine" class="anchored"><td class="def constructor"><a href="#type-unqualified.Machine" class="anchor"></a><code>| </code><code><span class="constructor">Machine</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>Size in bytes for now</p></td></tr><tr id="type-unqualified.Cint" class="anchored"><td class="def constructor"><a href="#type-unqualified.Cint" class="anchor"></a><code>| </code><code><span class="constructor">Cint</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-unqualified.name" class="anchored"><td class="def field"><a href="#type-unqualified.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-unqualified.signed" class="anchored"><td class="def field"><a href="#type-unqualified.signed" class="anchor"></a><code>signed : bool;</code></td></tr><tr id="type-unqualified.size" class="anchored"><td class="def field"><a href="#type-unqualified.size" class="anchor"></a><code>size : int;</code></td></tr><tr id="type-unqualified.ischar" class="anchored"><td class="def field"><a href="#type-unqualified.ischar" class="anchor"></a><code>ischar : bool;</code></td></tr></table><code>}</code></td></tr><tr id="type-unqualified.Cbool" class="anchored"><td class="def constructor"><a href="#type-unqualified.Cbool" class="anchor"></a><code>| </code><code><span class="constructor">Cbool</span></code></td></tr><tr id="type-unqualified.Ptr" class="anchored"><td class="def constructor"><a href="#type-unqualified.Ptr" class="anchor"></a><code>| </code><code><span class="constructor">Ptr</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-unqualified.fragment" class="anchored"><td class="def field"><a href="#type-unqualified.fragment" class="anchor"></a><code>fragment : <a href="index.html#type-fragment">fragment</a>;</code></td></tr><tr id="type-unqualified.offset" class="anchored"><td class="def field"><a href="#type-unqualified.offset" class="anchor"></a><code>offset : <a href="index.html#type-offset">offset</a>;</code></td></tr><tr id="type-unqualified.provenance" class="anchored"><td class="def field"><a href="#type-unqualified.provenance" class="anchor"></a><code>provenance : <a href="index.html#type-provenance">provenance</a>;</code></td></tr></table><code>}</code></td><td class="doc"><p><code>fragment</code> is about a type fragment. <code>offset</code> is the position in that type fragment. <code>provenance</code> is about a runtime symbolic block (see <a href="../State/Mem/index.html"><code>State.Mem</code></a>).</p></td></tr><tr id="type-unqualified.Struct" class="anchored"><td class="def constructor"><a href="#type-unqualified.Struct" class="anchor"></a><code>| </code><code><span class="constructor">Struct</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-unqualified.name" class="anchored"><td class="def field"><a href="#type-unqualified.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-unqualified.size" class="anchored"><td class="def field"><a href="#type-unqualified.size" class="anchor"></a><code>size : int;</code></td></tr><tr id="type-unqualified.id" class="anchored"><td class="def field"><a href="#type-unqualified.id" class="anchor"></a><code>id : int;</code></td></tr></table><code>}</code></td><td class="doc"><p>See <a href="index.html#type-env"><code>env</code></a> for what the id refers to. The int is the size</p></td></tr><tr id="type-unqualified.Array" class="anchored"><td class="def constructor"><a href="#type-unqualified.Array" class="anchor"></a><code>| </code><code><span class="constructor">Array</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-unqualified.elem" class="anchored"><td class="def field"><a href="#type-unqualified.elem" class="anchor"></a><code>elem : <a href="index.html#type-t">t</a>;</code></td></tr><tr id="type-unqualified.dims" class="anchored"><td class="def field"><a href="#type-unqualified.dims" class="anchor"></a><code>dims : <span><span>int option</span> list</span>;</code></td></tr></table><code>}</code></td></tr><tr id="type-unqualified.Enum" class="anchored"><td class="def constructor"><a href="#type-unqualified.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-unqualified.name" class="anchored"><td class="def field"><a href="#type-unqualified.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-unqualified.id" class="anchored"><td class="def field"><a href="#type-unqualified.id" class="anchor"></a><code>id : int;</code></td></tr></table><code>}</code></td><td class="doc"><p>See <a href="index.html#type-env"><code>env</code></a> for what the id refers to</p></td></tr><tr id="type-unqualified.FuncPtr" class="anchored"><td class="def constructor"><a href="#type-unqualified.FuncPtr" class="anchor"></a><code>| </code><code><span class="constructor">FuncPtr</span></code></td><td class="doc"><p>Hack to accommodate PKVM</p></td></tr><tr id="type-unqualified.Missing" class="anchored"><td class="def constructor"><a href="#type-unqualified.Missing" class="anchor"></a><code>| </code><code><span class="constructor">Missing</span></code></td><td class="doc"><p>Hack to accommodate PKVM</p></td></tr></table></dt><dd><p>The unqualified part of the C type without const volatile, ...</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">and</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.unqualified" class="anchored"><td class="def field"><a href="#type-t.unqualified" class="anchor"></a><code>unqualified : <a href="index.html#type-unqualified">unqualified</a>;</code></td></tr><tr id="type-t.const" class="anchored"><td class="def field"><a href="#type-t.const" class="anchor"></a><code>const : bool;</code></td></tr><tr id="type-t.volatile" class="anchored"><td class="def field"><a href="#type-t.volatile" class="anchor"></a><code>volatile : bool;</code></td></tr><tr id="type-t.restrict" class="anchored"><td class="def field"><a href="#type-t.restrict" class="anchor"></a><code>restrict : bool;</code></td></tr><tr id="type-t.constexpr" class="anchored"><td class="def field"><a href="#type-t.constexpr" class="anchor"></a><code>constexpr : bool;</code></td></tr></table><code>}</code></dt><dd><p>The internal representation of generalized C types</p></dd></dl><dl><dt class="spec type" id="type-fragment"><a href="#type-fragment" class="anchor"></a><code><span class="keyword">and</span> fragment</code><code> = </code><table class="variant"><tr id="type-fragment.Unknown" class="anchored"><td class="def constructor"><a href="#type-fragment.Unknown" class="anchor"></a><code>| </code><code><span class="constructor">Unknown</span></code></td><td class="doc"><p>Unknown type, But without possibility of learning</p></td></tr><tr id="type-fragment.Single" class="anchored"><td class="def constructor"><a href="#type-fragment.Single" class="anchor"></a><code>| </code><code><span class="constructor">Single</span> <span class="keyword">of</span> <a href="index.html#type-t">t</a></code></td><td class="doc"><p>Single object: Only when accessing of a global variable</p></td></tr><tr id="type-fragment.DynArray" class="anchored"><td class="def constructor"><a href="#type-fragment.DynArray" class="anchor"></a><code>| </code><code><span class="constructor">DynArray</span> <span class="keyword">of</span> <a href="index.html#type-t">t</a></code></td><td class="doc"><p>Generic C pointer, may point to multiple element of that type</p></td></tr><tr id="type-fragment.DynFragment" class="anchored"><td class="def constructor"><a href="#type-fragment.DynFragment" class="anchor"></a><code>| </code><code><span class="constructor">DynFragment</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>Writable fragment for memory whose type is changing dynamically</p></td></tr><tr id="type-fragment.Global" class="anchored"><td class="def constructor"><a href="#type-fragment.Global" class="anchor"></a><code>| </code><code><span class="constructor">Global</span></code></td><td class="doc"><p>The Global fragment that contains all the fixed ELF section .text, .data, .rodata, ...</p></td></tr></table></dt><dd><p>The type of a memory fragment</p></dd></dl><dl><dt class="spec type" id="type-offset"><a href="#type-offset" class="anchor"></a><code><span class="keyword">and</span> offset</code><code> = </code><table class="variant"><tr id="type-offset.Const" class="anchored"><td class="def constructor"><a href="#type-offset.Const" class="anchor"></a><code>| </code><code><span class="constructor">Const</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>Constant offset</p></td></tr><tr id="type-offset.Somewhere" class="anchored"><td class="def constructor"><a href="#type-offset.Somewhere" class="anchor"></a><code>| </code><code><span class="constructor">Somewhere</span></code></td></tr></table></dt><dd><p>The type of an offset in a fragment</p></dd></dl><dl><dt class="spec type" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span class="keyword">type</span> linksem_t</code><code> = Dwarf.c_type</code></dt><dd><p>The type of C types in Linksem</p></dd></dl><dl><dt class="spec type" id="type-field"><a href="#type-field" class="anchor"></a><code><span class="keyword">type</span> field</code><code> = </code><code>{</code><table class="record"><tr id="type-field.fname" class="anchored"><td class="def field"><a href="#type-field.fname" class="anchor"></a><code>fname : <span>string option</span>;</code></td></tr><tr id="type-field.offset" class="anchored"><td class="def field"><a href="#type-field.offset" class="anchor"></a><code>offset : int;</code></td></tr><tr id="type-field.typ" class="anchored"><td class="def field"><a href="#type-field.typ" class="anchor"></a><code>typ : <a href="index.html#type-t">t</a>;</code></td></tr><tr id="type-field.size" class="anchored"><td class="def field"><a href="#type-field.size" class="anchor"></a><code>size : int;</code></td></tr></table><code>}</code></dt><dd><p>A field in a structure</p></dd></dl><dl><dt class="spec type" id="type-linksem_field"><a href="#type-linksem_field" class="anchor"></a><code><span class="keyword">type</span> linksem_field</code><code> = <span><a href="index.html#type-linksem_t">linksem_t</a> Dwarf.struct_union_member</span></code></dt></dl><dl><dt class="spec module" id="module-FieldMap"><a href="#module-FieldMap" class="anchor"></a><code><span class="keyword">module</span> <a href="FieldMap/index.html">FieldMap</a> : <a href="../Utils/RngMap/index.html#module-type-S">Utils.RngMap.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../Utils/RngMap/module-type-S/index.html#type-obj">obj</a> = <a href="index.html#type-field">field</a></code></dt><dd><p>A range map over field to represent a structure layout</p></dd></dl><dl><dt class="spec type" id="type-struc"><a href="#type-struc" class="anchor"></a><code><span class="keyword">type</span> struc</code><code> = </code><code>{</code><table class="record"><tr id="type-struc.layout" class="anchored"><td class="def field"><a href="#type-struc.layout" class="anchor"></a><code>layout : <a href="FieldMap/index.html#type-t">FieldMap.t</a>;</code></td></tr><tr id="type-struc.name" class="anchored"><td class="def field"><a href="#type-struc.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-struc.size" class="anchored"><td class="def field"><a href="#type-struc.size" class="anchor"></a><code>size : int;</code></td></tr><tr id="type-struc.complete" class="anchored"><td class="def field"><a href="#type-struc.complete" class="anchor"></a><code>complete : bool;</code></td></tr></table><code>}</code></dt><dd><p>The type of a C structure.</p><p>A structure can be complete or incomplete but due to some internal hackery this is a need for a subtle difference with C: Even incomplete structure have a size, they just don't have any field.</p><p>A incomplete struct can and will often be complete later as the interpretation of DWARF information advances.</p><p>The name field is the linking name of the struct.</p></dd></dl><dl><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = </code><code>{</code><table class="record"><tr id="type-enum.name" class="anchored"><td class="def field"><a href="#type-enum.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-enum.labels" class="anchored"><td class="def field"><a href="#type-enum.labels" class="anchor"></a><code>labels : <span><span>(int, <span>string option</span>)</span> Stdlib.Hashtbl.t</span>;</code></td></tr></table><code>}</code></dt><dd><p>The representation type of a C enumeration</p></dd></dl><dl><dt class="spec type" id="type-cupdie_id"><a href="#type-cupdie_id" class="anchor"></a><code><span class="keyword">type</span> cupdie_id</code><code> = int * int</code></dt><dd><p>The identifier for a linksem_cupdie. See <a href="index.html#val-ids_of_cupdie"><code>ids_of_cupdie</code></a></p></dd></dl><dl><dt class="spec type" id="type-linksem_env"><a href="#type-linksem_env" class="anchor"></a><code><span class="keyword">type</span> linksem_env</code><code> = <span><a href="index.html#type-linksem_t">linksem_t</a> list</span></code></dt><dd><p>The type of environement linksem gives us.</p><p>Only structs, enums and unions can appear. A type can appear multiple times and also be forward-declared with missing data like size. <a href="index.html#val-env_of_linksem"><code>env_of_linksem</code></a> hopefully deals with all those problems</p></dd></dl><dl><dt class="spec type" id="type-linksem_indexed_env"><a href="#type-linksem_indexed_env" class="anchor"></a><code><span class="keyword">type</span> linksem_indexed_env</code><code> = <span><span>(<a href="index.html#type-cupdie_id">cupdie_id</a>, <a href="index.html#type-linksem_t">linksem_t</a>)</span> Stdlib.Hashtbl.t</span></code></dt><dd><p>An version of the linksem environement indexed by <a href="index.html#type-cupdie_id"><code>cupdie_id</code></a></p></dd></dl><dl><dt class="spec type" id="type-env"><a href="#type-env" class="anchor"></a><code><span class="keyword">type</span> env</code><code> = </code><code>{</code><table class="record"><tr id="type-env.structs" class="anchored"><td class="def field"><a href="#type-env.structs" class="anchor"></a><code>structs : <span><span>(string, <a href="index.html#type-struc">struc</a>)</span> <a href="../Utils/IdMap/index.html#type-t">Utils.IdMap.t</a></span>;</code></td></tr><tr id="type-env.enums" class="anchored"><td class="def field"><a href="#type-env.enums" class="anchor"></a><code>enums : <span><span>(string, <a href="index.html#type-enum">enum</a>)</span> <a href="../Utils/IdMap/index.html#type-t">Utils.IdMap.t</a></span>;</code></td></tr><tr id="type-env.lenv" class="anchored"><td class="def field"><a href="#type-env.lenv" class="anchor"></a><code>lenv : <a href="index.html#type-linksem_indexed_env">linksem_indexed_env</a>;</code></td></tr></table><code>}</code></dt><dd><p>The type environment that contain mapping from linking name and a generated id</p><p>to the actual content of structs and enumerations.</p><p>Linking names can be:</p><ul><li>A plain name for a struct/enum declared with a tag.</li><li><code>typedef.name</code> for an unnamed struct declared in a typedef</li><li><code>outer.member</code> for unnamed struct used as the type of a <code>member</code> of a struct with linking name <code>outer</code>.</li></ul><p>As an unnamed struct can be declared in the linksem environement but used with the typedef only after the initial environement setup of <a href="index.html#val-env_of_linksem"><code>env_of_linksem</code></a>, the original linksem type must be kept alive in <code>lenv</code></p></dd></dl><dl><dt class="spec value" id="val-ptr_size"><a href="#val-ptr_size" class="anchor"></a><code><span class="keyword">val</span> ptr_size : int</code></dt><dd><p>The size of pointer. This will be configurable later</p></dd></dl><dl><dt class="spec value" id="val-enum_size"><a href="#val-enum_size" class="anchor"></a><code><span class="keyword">val</span> enum_size : int</code></dt><dd><p>The size of enums. This will be configurable later</p></dd></dl></section><section><header><h2 id="comparisons"><a href="#comparisons" class="anchor"></a>Comparisons</h2></header><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt></dl></section><section><header><h2 id="convenience-manipulation"><a href="#convenience-manipulation" class="anchor"></a>Convenience manipulation</h2></header><dl><dt class="spec value" id="val-is_struct"><a href="#val-is_struct" class="anchor"></a><code><span class="keyword">val</span> is_struct : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_array"><a href="#val-is_array" class="anchor"></a><code><span class="keyword">val</span> is_array : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_ptr"><a href="#val-is_ptr" class="anchor"></a><code><span class="keyword">val</span> is_ptr : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_scalar"><a href="#val-is_scalar" class="anchor"></a><code><span class="keyword">val</span> is_scalar : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_composite"><a href="#val-is_composite" class="anchor"></a><code><span class="keyword">val</span> is_composite : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_constexpr"><a href="#val-is_constexpr" class="anchor"></a><code><span class="keyword">val</span> is_constexpr : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-ptr"><a href="#val-ptr" class="anchor"></a><code><span class="keyword">val</span> ptr : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-unqualified">unqualified</a></code></dt><dd><p>Make a simple pointer from a type</p></dd></dl><dl><dt class="spec value" id="val-voidstar"><a href="#val-voidstar" class="anchor"></a><code><span class="keyword">val</span> voidstar : <a href="index.html#type-unqualified">unqualified</a></code></dt><dd><p>A void* pointer</p></dd></dl><dl><dt class="spec value" id="val-qual"><a href="#val-qual" class="anchor"></a><code><span class="keyword">val</span> qual : <span>?&#8288;const:bool</span> <span>&#45;&gt;</span> <span>?&#8288;volatile:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restrict:bool</span> <span>&#45;&gt;</span> <span>?&#8288;constexpr:bool</span> <span>&#45;&gt;</span> <a href="index.html#type-unqualified">unqualified</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a qualified type from an unqualified type with the specified qualifiers</p></dd></dl><dl><dt class="spec value" id="val-add_qual"><a href="#val-add_qual" class="anchor"></a><code><span class="keyword">val</span> add_qual : <span>?&#8288;const:bool</span> <span>&#45;&gt;</span> <span>?&#8288;volatile:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restrict:bool</span> <span>&#45;&gt;</span> <span>?&#8288;constexpr:bool</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>update specified qualifiers. Other qualifier are kept</p></dd></dl><dl><dt class="spec value" id="val-machine"><a href="#val-machine" class="anchor"></a><code><span class="keyword">val</span> machine : <span>?&#8288;constexpr:bool</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a machine type of that size without qualifiers</p></dd></dl><dl><dt class="spec value" id="val-of_frag"><a href="#val-of_frag" class="anchor"></a><code><span class="keyword">val</span> of_frag : <span>?&#8288;provenance:<a href="index.html#type-provenance">provenance</a></span> <span>&#45;&gt;</span> <span>?&#8288;offset:int</span> <span>&#45;&gt;</span> <span>?&#8288;constexpr:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restrict:bool</span> <span>&#45;&gt;</span> <a href="index.html#type-fragment">fragment</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a pointer to fragment with specified offset (0 by default)</p></dd></dl><dl><dt class="spec value" id="val-of_frag_somewhere"><a href="#val-of_frag_somewhere" class="anchor"></a><code><span class="keyword">val</span> of_frag_somewhere : <span>?&#8288;provenance:<a href="index.html#type-provenance">provenance</a></span> <span>&#45;&gt;</span> <span>?&#8288;constexpr:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restrict:bool</span> <span>&#45;&gt;</span> <a href="index.html#type-fragment">fragment</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a pointer to fragment Somewhere</p></dd></dl><dl><dt class="spec value" id="val-incomplete_struct"><a href="#val-incomplete_struct" class="anchor"></a><code><span class="keyword">val</span> incomplete_struct : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-struc">struc</a></code></dt><dd><p>Build an incomplete struct with a linking name and a size</p></dd></dl><dl><dt class="spec value" id="val-make_env"><a href="#val-make_env" class="anchor"></a><code><span class="keyword">val</span> make_env : <a href="index.html#type-linksem_indexed_env">linksem_indexed_env</a> <span>&#45;&gt;</span> <a href="index.html#type-env">env</a></code></dt><dd><p>Makes an empty environement from and indexed linksem environement</p></dd></dl><dl><dt class="spec value" id="val-offset_update"><a href="#val-offset_update" class="anchor"></a><code><span class="keyword">val</span> offset_update : <a href="index.html#type-offset">offset</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-offset">offset</a></code></dt><dd><p>Update an <a href="index.html#type-offset"><code>offset</code></a> with an integer update</p></dd></dl><dl><dt class="spec value" id="val-ptr_update"><a href="#val-ptr_update" class="anchor"></a><code><span class="keyword">val</span> ptr_update : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Update an pointer with an integer update</p></dd></dl><dl><dt class="spec value" id="val-ptr_set"><a href="#val-ptr_set" class="anchor"></a><code><span class="keyword">val</span> ptr_set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Set a arbitrary new offset in a pointer</p></dd></dl><dl><dt class="spec value" id="val-ptr_forget"><a href="#val-ptr_forget" class="anchor"></a><code><span class="keyword">val</span> ptr_forget : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Make a pointer forget it's offset</p></dd></dl></section><section><header><h2 id="sizeof"><a href="#sizeof" class="anchor"></a>Sizeof</h2><p>This section give implementation of sizeof function.</p><p>Dynamic array have size 0 until we are able to deal with C99 last member dynamic arrays. This will mess up with <a href="index.html#val-type_at"><code>type_at</code></a>. TODO fix it.</p></header><dl><dt class="spec value" id="val-sizeof_unqualified"><a href="#val-sizeof_unqualified" class="anchor"></a><code><span class="keyword">val</span> sizeof_unqualified : <a href="index.html#type-unqualified">unqualified</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Give the size of an <a href="index.html#type-unqualified"><code>unqualified</code></a> type. Need the environement.</p></dd></dl><dl><dt class="spec value" id="val-sizeof"><a href="#val-sizeof" class="anchor"></a><code><span class="keyword">val</span> sizeof : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Give the size of an type. Need the environement.</p></dd></dl><dl><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>For being used in <span class="xref-unresolved" title="unresolved reference to &quot;RngMap.LenObject&quot;"><code>RngMap</code>.LenObject</span></p></dd></dl></section><section><header><h2 id="ctyplink"><a href="#ctyplink" class="anchor"></a>C type linking: From Linksem</h2><p>This section contain the whole hierarchy of function used to convert type from DWARF representation to the internal type system.</p><p>During this conversion, C type linking happens. This means that structure with the same name from different compilation unit are identified as being the same. If they do not have the same layout, an error is raised. This would mean that either the C program does very weird thing with it's type that we don't want to verify or more likely that it is ill-formed. As we have to deal with anonymous struct, name are a bit more complex than plain <code>struct</code> tags. See <a href="index.html#type-env"><code>env</code></a> for a description.</p><p>The top-level interface for types is <a href="index.html#val-of_linksem"><code>of_linksem</code></a> and the top-level interface for environement is <a href="index.html#val-env_of_linksem"><code>env_of_linksem</code></a>. Those will be called by <a href="../Dw/index.html"><code>Dw</code></a> at DWARF loading time to generate a coherent type system.</p></header><dl><dt class="spec type" id="type-conversion_context"><a href="#type-conversion_context" class="anchor"></a><code><span class="keyword">type</span> conversion_context</code><code> = </code><code>{</code><table class="record"><tr id="type-conversion_context.env" class="anchored"><td class="def field"><a href="#type-conversion_context.env" class="anchor"></a><code>env : <a href="index.html#type-env">env</a>;</code></td></tr><tr id="type-conversion_context.potential_link_name" class="anchored"><td class="def field"><a href="#type-conversion_context.potential_link_name" class="anchor"></a><code>potential_link_name : <span>string option</span>;</code></td></tr></table><code>}</code></dt><dd><p>This type is a conversion context.</p><p>Its role is to contain all the things that all the functions in this section will need to convert types.</p></dd></dl><dl><dt class="spec value" id="val-ids_of_cupdie"><a href="#val-ids_of_cupdie" class="anchor"></a><code><span class="keyword">val</span> ids_of_cupdie : Dwarf.cupdie <span>&#45;&gt;</span> <a href="index.html#type-cupdie_id">cupdie_id</a></code></dt><dd><p>Get the id of a linksem <code>cupdie</code></p></dd></dl><dl><dt class="spec value" id="val-pp_decl"><a href="#val-pp_decl" class="anchor"></a><code><span class="keyword">val</span> pp_decl : Dwarf.decl <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty print the dwarf decl type</p><p>TODO: Move that in the appropriate place</p></dd></dl><dl><dt class="spec exception" id="exception-LinkError"><a href="#exception-LinkError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">LinkError</span></code></dt><dd><p>This exception is raised when the type we are trying to reach must came from another translation unit or later in the current one.</p><p>The information is incomplete at this moment to create is.</p><p>Normally this exception should only happen during the initial <a href="index.html#val-env_of_linksem"><code>env_of_linksem</code></a>. If it happens elsewhere, either the code used an anonymous struct that do not have C++-like linkage or the compiler did not do its job.</p></dd></dl><dl><dt class="spec value" id="val-expect_some_link"><a href="#val-expect_some_link" class="anchor"></a><code><span class="keyword">val</span> expect_some_link : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-base_type_of_linksem"><a href="#val-base_type_of_linksem" class="anchor"></a><code><span class="keyword">val</span> base_type_of_linksem : <span>?&#8288;size:Z.t</span> <span>&#45;&gt;</span> <span>encoding:Z.t</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-unqualified">unqualified</a></code></dt><dd><p>Convert a base type with a name and encoding and maybe a size to its inner representation</p><p>Only integers, chars and bools supported. No floating points</p></dd></dl><dl><dt class="spec value" id="val-field_of_linksem"><a href="#val-field_of_linksem" class="anchor"></a><code><span class="keyword">val</span> field_of_linksem : <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> <a href="index.html#type-linksem_field">linksem_field</a> <span>&#45;&gt;</span> <a href="FieldMap/index.html#type-obj">FieldMap.obj</a></code></dt><dt class="spec value" id="val-field_map_of_linksem"><a href="#val-field_map_of_linksem" class="anchor"></a><code><span class="keyword">val</span> field_map_of_linksem : string <span>&#45;&gt;</span> <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-linksem_field">linksem_field</a> list</span> <span>&#45;&gt;</span> <a href="FieldMap/index.html#type-t">FieldMap.t</a></code></dt><dt class="spec value" id="val-struc_of_linksem"><a href="#val-struc_of_linksem" class="anchor"></a><code><span class="keyword">val</span> struc_of_linksem : <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-linksem_field">linksem_field</a> list</span> <span>&#45;&gt;</span> <a href="index.html#type-struc">struc</a></code></dt><dt class="spec value" id="val-struct_type_of_linksem"><a href="#val-struct_type_of_linksem" class="anchor"></a><code><span class="keyword">val</span> struct_type_of_linksem : <span>?&#8288;force_complete:bool</span> <span>&#45;&gt;</span> <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> <span>cupdie:Dwarf.cupdie</span> <span>&#45;&gt;</span> <span>mname:<span>string option</span></span> <span>&#45;&gt;</span> <span>decl:Dwarf.decl</span> <span>&#45;&gt;</span> <a href="index.html#type-unqualified">unqualified</a></code></dt><dd><p>Build a struct from it's cupdie and name. If <code>force_complete</code> is true and the struct is incomplete. It will try to complete is using <code>cupdie</code> and throw <a href="index.html#exception-LinkError"><code>LinkError</code></a> if it fails.</p></dd></dl><dl><dt class="spec value" id="val-enum_of_linksem"><a href="#val-enum_of_linksem" class="anchor"></a><code><span class="keyword">val</span> enum_of_linksem : <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>Dwarf.enumeration_member list</span> <span>&#45;&gt;</span> <a href="index.html#type-enum">enum</a></code></dt><dt class="spec value" id="val-enum_type_of_linksem"><a href="#val-enum_type_of_linksem" class="anchor"></a><code><span class="keyword">val</span> enum_type_of_linksem : <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> <span>cupdie:Dwarf.cupdie</span> <span>&#45;&gt;</span> <span>mname:<span>string option</span></span> <span>&#45;&gt;</span> <span>decl:Dwarf.decl</span> <span>&#45;&gt;</span> <a href="index.html#type-unqualified">unqualified</a></code></dt><dt class="spec value" id="val-unqualified_of_linksem"><a href="#val-unqualified_of_linksem" class="anchor"></a><code><span class="keyword">val</span> unqualified_of_linksem : <span>?&#8288;force_complete:bool</span> <span>&#45;&gt;</span> <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-unqualified">unqualified</a></code></dt><dd><p>Convert an unqualified type. Union are just <code>Machine n</code> where n is their size</p></dd></dl><dl><dt class="spec value" id="val-of_linksem_none"><a href="#val-of_linksem_none" class="anchor"></a><code><span class="keyword">val</span> of_linksem_none : unit <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Placeholder for whatever the right thing to do is when linksem found no type - TODO: fix</p></dd></dl><dl><dt class="spec value" id="val-of_linksem_cc"><a href="#val-of_linksem_cc" class="anchor"></a><code><span class="keyword">val</span> of_linksem_cc : <span>?&#8288;force_complete:bool</span> <span>&#45;&gt;</span> <span>cc:<a href="index.html#type-conversion_context">conversion_context</a></span> <span>&#45;&gt;</span> <span>?&#8288;const:bool</span> <span>&#45;&gt;</span> <span>?&#8288;volatile:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restrict:bool</span> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>The main <code>of_linksem</code> that take a full conversion_context and qualifiers.</p><p>The user friendly version is <a href="index.html#val-of_linksem"><code>of_linksem</code></a></p><p>See <a href="index.html#val-struct_type_of_linksem"><code>struct_type_of_linksem</code></a> for the explanation of <code>force_complete</code>.</p><p>All the qualifier passed as parameter are added to the resulting type.</p></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : <span>env:<a href="index.html#type-env">env</a></span> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>The user friendly interface that convert a type using the environment. This useful when there is no additional linking information to pass on</p></dd></dl><dl><dt class="spec value" id="val-env_of_linksem"><a href="#val-env_of_linksem" class="anchor"></a><code><span class="keyword">val</span> env_of_linksem : <a href="index.html#type-linksem_env">linksem_env</a> <span>&#45;&gt;</span> <a href="index.html#type-env">env</a></code></dt><dd><p>The main environment conversion function.</p><p>This the function that deal with all the type linking process, forward declaration an all that stuff.</p><p>First it create the indexed linksem environment (member lenv of <a href="index.html#type-env"><code>env</code></a>),</p><p>Then it registers all named structs as incomplete in the environment (to deal with self recursion, only named structs can self-recurse).</p><p>Finally it run <a href="index.html#val-of_linksem_cc"><code>of_linksem_cc</code></a> on all the types with <code>force_complete</code> on. During this phase it ignore all <a href="index.html#exception-LinkError"><code>LinkError</code></a> that arise. It assumes that if some thing was incomplete at that point, it will become complete later.</p><p>Then it can return the freshly built environment.</p><p>If some structs are still incomplete, but are actually used, the <a href="index.html#exception-LinkError"><code>LinkError</code></a> will be raised at the time of use.</p></dd></dl></section><section><header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2></header><dl><dt class="spec value" id="val-pp_signed"><a href="#val-pp_signed" class="anchor"></a><code><span class="keyword">val</span> pp_signed : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a type. If an environement is provided, structs and enums will be printed with a name, otherwise they will just have a number</p></dd></dl><dl><dt class="spec value" id="val-pp_unqualified"><a href="#val-pp_unqualified" class="anchor"></a><code><span class="keyword">val</span> pp_unqualified : <a href="index.html#type-unqualified">unqualified</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_fragment"><a href="#val-pp_fragment" class="anchor"></a><code><span class="keyword">val</span> pp_fragment : <a href="index.html#type-fragment">fragment</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_offset"><a href="#val-pp_offset" class="anchor"></a><code><span class="keyword">val</span> pp_offset : <a href="index.html#type-offset">offset</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_arr"><a href="#val-pp_arr" class="anchor"></a><code><span class="keyword">val</span> pp_arr : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>int option</span> list</span> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_arr_dim"><a href="#val-pp_arr_dim" class="anchor"></a><code><span class="keyword">val</span> pp_arr_dim : <span>int option</span> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_field"><a href="#val-pp_field" class="anchor"></a><code><span class="keyword">val</span> pp_field : <a href="index.html#type-field">field</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_struct"><a href="#val-pp_struct" class="anchor"></a><code><span class="keyword">val</span> pp_struct : <a href="index.html#type-struc">struc</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_enums"><a href="#val-pp_enums" class="anchor"></a><code><span class="keyword">val</span> pp_enums : <a href="index.html#type-enum">enum</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_env"><a href="#val-pp_env" class="anchor"></a><code><span class="keyword">val</span> pp_env : <a href="index.html#type-env">env</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Print the whole environement (not the linksem indexed environment)</p></dd></dl></section><section><header><h2 id="type-at"><a href="#type-at" class="anchor"></a>Type at</h2><p>This section is about getting the type at a specific offset in things.</p></header><dl><dt class="spec value" id="val-struct_at"><a href="#val-struct_at" class="anchor"></a><code><span class="keyword">val</span> struct_at : <span>env:<a href="index.html#type-env">env</a></span> <span>&#45;&gt;</span> <span>size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-struc">struc</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> <a href="../Utils/index.html#module-Option">Utils.Option</a>.t</span></code></dt><dd><p>Same as <a href="index.html#val-type_at"><code>type_at</code></a> but for structs</p></dd></dl><dl><dt class="spec value" id="val-type_at"><a href="#val-type_at" class="anchor"></a><code><span class="keyword">val</span> type_at : <span>env:<a href="index.html#type-env">env</a></span> <span>&#45;&gt;</span> <span>size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> <a href="../Utils/index.html#module-Option">Utils.Option</a>.t</span></code></dt><dd><p>Get the type of size <code>size</code> at the provided offset in another type</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Ctype (read-dwarf.Ctype)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Ctype</nav><header class="odoc-preamble"><h1>Module <code><span>Ctype</span></code></h1><p>This module provides the internal C-like type system. This type system is slightly different than the normal C type system. This module only provides the Ocaml datastructure to represent those types. The typing rules are implemented in <code>Trace.Typer</code>, where they are applied dire</p><p>These types follow the normal C type structure except for pointers that are more complex. To handle the fact that the C compiler knows perfectly the ABI and is &quot;allowed&quot; to used it, we have to make pointer types resist manual adjusting of pointers to point to the field of a struct. However the new pointer cannot just have type <code>field_type*</code> because one could want to get back a pointer to the whole structure by subtracting an offset from the field pointer. Thus a pointer must never forget information about its surroundings. Those surroundings are called a <a href="#type-fragment"><code>fragment</code></a> and represent all the type information of the fragment of memory in which a pointer lies. The pointer is thus represented as a fragment of memory and an offset. Since the pointer type is more complex and packs more information, the surface syntax has changed. A pointer type is written between braces, so <code>A*</code> becomes <code>{A}</code>, but in more complex cases, all informations fit between the braces.</p><p>Furthermore, the fragment part of the pointer does not record any information about aliasing: two different type fragments are perfectly allowed to alias. To handle non-aliasing properties, like the stack not aliasing the heap or restrict pointers, pointers also have a <code>provenance</code> field. See <a href="../State/Base/Mem/index.html"><code>State.Mem</code></a>.</p><p>There is another problem: The C language does not define a C type system for the whole program, contrary to C++. It defines only a type system per compilation unit. This limitation is too annoying to work with so the module implements some kind of linking of types, similar to C++ rules. See <a href="#ctyplink" title="ctyplink">C type linking: From Linksem</a>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#dwarf-constants">DWARF constants</a></li><li><a href="#types">Types</a></li><li><a href="#comparisons">Comparisons</a></li><li><a href="#convenience-manipulation">Convenience manipulation</a></li><li><a href="#sizeof">Sizeof</a></li><li><a href="#ctyplink">C type linking: From Linksem</a></li><li><a href="#pretty-printing">Pretty printing</a></li><li><a href="#type-at">Type at</a></li></ul></nav></div><div class="odoc-content"><h2 id="dwarf-constants"><a href="#dwarf-constants" class="anchor"></a>DWARF constants</h2><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_ATE_address"><a href="#val-vDW_ATE_address" class="anchor"></a><code><span><span class="keyword">val</span> vDW_ATE_address : int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_ATE_boolean"><a href="#val-vDW_ATE_boolean" class="anchor"></a><code><span><span class="keyword">val</span> vDW_ATE_boolean : int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_ATE_signed"><a href="#val-vDW_ATE_signed" class="anchor"></a><code><span><span class="keyword">val</span> vDW_ATE_signed : int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_ATE_signed_char"><a href="#val-vDW_ATE_signed_char" class="anchor"></a><code><span><span class="keyword">val</span> vDW_ATE_signed_char : int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_ATE_unsigned"><a href="#val-vDW_ATE_unsigned" class="anchor"></a><code><span><span class="keyword">val</span> vDW_ATE_unsigned : int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_ATE_unsigned_char"><a href="#val-vDW_ATE_unsigned_char" class="anchor"></a><code><span><span class="keyword">val</span> vDW_ATE_unsigned_char : int</span></code></div></div><h2 id="types"><a href="#types" class="anchor"></a>Types</h2><div class="odoc-spec"><div class="spec type anchored" id="type-provenance"><a href="#type-provenance" class="anchor"></a><code><span><span class="keyword">type</span> provenance</span><span> = </span></code><ol><li id="type-provenance.Restricted" class="def variant constructor anchored"><a href="#type-provenance.Restricted" class="anchor"></a><code><span>| </span><span><span class="constructor">Restricted</span> <span class="keyword">of</span> int</span></code></li><li id="type-provenance.Main" class="def variant constructor anchored"><a href="#type-provenance.Main" class="anchor"></a><code><span>| </span><span><span class="constructor">Main</span></span></code></li></ol></div><div class="spec-doc"><p>This is the provenance of the pointer. This tells to which symbolic memory block a pointer points to. To get the full explanation, go to <a href="../State/Base/Mem/index.html"><code>State.Mem</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_provenance"><a href="#val-pp_provenance" class="anchor"></a><code><span><span class="keyword">val</span> pp_provenance : <span><a href="#type-provenance">provenance</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unqualified"><a href="#type-unqualified" class="anchor"></a><code><span><span class="keyword">type</span> unqualified</span><span> = </span></code><ol><li id="type-unqualified.Machine" class="def variant constructor anchored"><a href="#type-unqualified.Machine" class="anchor"></a><code><span>| </span><span><span class="constructor">Machine</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Size in bytes for now</p><span class="comment-delim">*)</span></div></li><li id="type-unqualified.Cint" class="def variant constructor anchored"><a href="#type-unqualified.Cint" class="anchor"></a><code><span>| </span><span><span class="constructor">Cint</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-unqualified.name" class="def record field anchored"><a href="#type-unqualified.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-unqualified.signed" class="def record field anchored"><a href="#type-unqualified.signed" class="anchor"></a><code><span>signed : bool;</span></code></li><li id="type-unqualified.size" class="def record field anchored"><a href="#type-unqualified.size" class="anchor"></a><code><span>size : int;</span></code></li><li id="type-unqualified.ischar" class="def record field anchored"><a href="#type-unqualified.ischar" class="anchor"></a><code><span>ischar : bool;</span></code></li></ol><code><span>}</span></code></li><li id="type-unqualified.Cbool" class="def variant constructor anchored"><a href="#type-unqualified.Cbool" class="anchor"></a><code><span>| </span><span><span class="constructor">Cbool</span></span></code></li><li id="type-unqualified.Ptr" class="def variant constructor anchored"><a href="#type-unqualified.Ptr" class="anchor"></a><code><span>| </span><span><span class="constructor">Ptr</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-unqualified.fragment" class="def record field anchored"><a href="#type-unqualified.fragment" class="anchor"></a><code><span>fragment : <a href="#type-fragment">fragment</a>;</span></code></li><li id="type-unqualified.offset" class="def record field anchored"><a href="#type-unqualified.offset" class="anchor"></a><code><span>offset : <a href="#type-offset">offset</a>;</span></code></li><li id="type-unqualified.provenance" class="def record field anchored"><a href="#type-unqualified.provenance" class="anchor"></a><code><span>provenance : <a href="#type-provenance">provenance</a>;</span></code></li></ol><code><span>}</span></code><div class="def-doc"><span class="comment-delim">(*</span><p><code>fragment</code> is about a type fragment. <code>offset</code> is the position in that type fragment. <code>provenance</code> is about a runtime symbolic block (see <a href="../State/Base/Mem/index.html"><code>State.Mem</code></a>).</p><span class="comment-delim">*)</span></div></li><li id="type-unqualified.Struct" class="def variant constructor anchored"><a href="#type-unqualified.Struct" class="anchor"></a><code><span>| </span><span><span class="constructor">Struct</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-unqualified.name" class="def record field anchored"><a href="#type-unqualified.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-unqualified.size" class="def record field anchored"><a href="#type-unqualified.size" class="anchor"></a><code><span>size : int;</span></code></li><li id="type-unqualified.id" class="def record field anchored"><a href="#type-unqualified.id" class="anchor"></a><code><span>id : int;</span></code></li></ol><code><span>}</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>See <a href="#type-conversion_context.env"><code>env</code></a> for what the id refers to. The int is the size</p><span class="comment-delim">*)</span></div></li><li id="type-unqualified.Array" class="def variant constructor anchored"><a href="#type-unqualified.Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Array</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-unqualified.elem" class="def record field anchored"><a href="#type-unqualified.elem" class="anchor"></a><code><span>elem : <a href="#type-t">t</a>;</span></code></li><li id="type-unqualified.dims" class="def record field anchored"><a href="#type-unqualified.dims" class="anchor"></a><code><span>dims : <span><span>int option</span> list</span>;</span></code></li></ol><code><span>}</span></code></li><li id="type-unqualified.Enum" class="def variant constructor anchored"><a href="#type-unqualified.Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Enum</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-unqualified.name" class="def record field anchored"><a href="#type-unqualified.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-unqualified.id" class="def record field anchored"><a href="#type-unqualified.id" class="anchor"></a><code><span>id : int;</span></code></li></ol><code><span>}</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>See <a href="#type-conversion_context.env"><code>env</code></a> for what the id refers to</p><span class="comment-delim">*)</span></div></li><li id="type-unqualified.FuncPtr" class="def variant constructor anchored"><a href="#type-unqualified.FuncPtr" class="anchor"></a><code><span>| </span><span><span class="constructor">FuncPtr</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Hack to accommodate PKVM</p><span class="comment-delim">*)</span></div></li><li id="type-unqualified.Missing" class="def variant constructor anchored"><a href="#type-unqualified.Missing" class="anchor"></a><code><span>| </span><span><span class="constructor">Missing</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Hack to accommodate PKVM</p><span class="comment-delim">*)</span></div></li><li id="type-unqualified.Bits" class="def variant constructor anchored"><a href="#type-unqualified.Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Bits</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Hack to prevent losing type information when processing bitvectors with non-whole-byte sizes</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The unqualified part of the C type without const volatile, ...</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">and</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.unqualified" class="def record field anchored"><a href="#type-t.unqualified" class="anchor"></a><code><span>unqualified : <a href="#type-unqualified">unqualified</a>;</span></code></li><li id="type-t.const" class="def record field anchored"><a href="#type-t.const" class="anchor"></a><code><span>const : bool;</span></code></li><li id="type-t.volatile" class="def record field anchored"><a href="#type-t.volatile" class="anchor"></a><code><span>volatile : bool;</span></code></li><li id="type-t.restrict" class="def record field anchored"><a href="#type-t.restrict" class="anchor"></a><code><span>restrict : bool;</span></code></li><li id="type-t.constexpr" class="def record field anchored"><a href="#type-t.constexpr" class="anchor"></a><code><span>constexpr : bool;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The internal representation of generalized C types</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-fragment"><a href="#type-fragment" class="anchor"></a><code><span><span class="keyword">and</span> fragment</span><span> = </span></code><ol><li id="type-fragment.Unknown" class="def variant constructor anchored"><a href="#type-fragment.Unknown" class="anchor"></a><code><span>| </span><span><span class="constructor">Unknown</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Unknown type, But without possibility of learning</p><span class="comment-delim">*)</span></div></li><li id="type-fragment.Single" class="def variant constructor anchored"><a href="#type-fragment.Single" class="anchor"></a><code><span>| </span><span><span class="constructor">Single</span> <span class="keyword">of</span> <a href="#type-t">t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Single object: Only when accessing of a global variable</p><span class="comment-delim">*)</span></div></li><li id="type-fragment.DynArray" class="def variant constructor anchored"><a href="#type-fragment.DynArray" class="anchor"></a><code><span>| </span><span><span class="constructor">DynArray</span> <span class="keyword">of</span> <a href="#type-t">t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Generic C pointer, may point to multiple element of that type</p><span class="comment-delim">*)</span></div></li><li id="type-fragment.DynFragment" class="def variant constructor anchored"><a href="#type-fragment.DynFragment" class="anchor"></a><code><span>| </span><span><span class="constructor">DynFragment</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Writable fragment for memory whose type is changing dynamically</p><span class="comment-delim">*)</span></div></li><li id="type-fragment.Global" class="def variant constructor anchored"><a href="#type-fragment.Global" class="anchor"></a><code><span>| </span><span><span class="constructor">Global</span> <span class="keyword">of</span> string</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The Global fragment that contains all the fixed ELF section .text, .data, .rodata, ...</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The type of a memory fragment</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-offset"><a href="#type-offset" class="anchor"></a><code><span><span class="keyword">and</span> offset</span><span> = </span></code><ol><li id="type-offset.Const" class="def variant constructor anchored"><a href="#type-offset.Const" class="anchor"></a><code><span>| </span><span><span class="constructor">Const</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Constant offset</p><span class="comment-delim">*)</span></div></li><li id="type-offset.Somewhere" class="def variant constructor anchored"><a href="#type-offset.Somewhere" class="anchor"></a><code><span>| </span><span><span class="constructor">Somewhere</span></span></code></li></ol></div><div class="spec-doc"><p>The type of an offset in a fragment</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span><span class="keyword">type</span> linksem_t</span><span> = <span class="xref-unresolved">Dwarf</span>.c_type</span></code></div><div class="spec-doc"><p>The type of C types in Linksem</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-field"><a href="#type-field" class="anchor"></a><code><span><span class="keyword">type</span> field</span><span> = </span><span>{</span></code><ol><li id="type-field.fname" class="def record field anchored"><a href="#type-field.fname" class="anchor"></a><code><span>fname : <span>string option</span>;</span></code></li><li id="type-field.offset" class="def record field anchored"><a href="#type-field.offset" class="anchor"></a><code><span>offset : int;</span></code></li><li id="type-field.typ" class="def record field anchored"><a href="#type-field.typ" class="anchor"></a><code><span>typ : <a href="#type-t">t</a>;</span></code></li><li id="type-field.size" class="def record field anchored"><a href="#type-field.size" class="anchor"></a><code><span>size : int;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>A field in a structure</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_field"><a href="#type-linksem_field" class="anchor"></a><code><span><span class="keyword">type</span> linksem_field</span><span> = <span><a href="#type-linksem_t">linksem_t</a> <span class="xref-unresolved">Dwarf</span>.struct_union_member</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-FieldMap"><a href="#module-FieldMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="FieldMap/index.html">FieldMap</a></span><span> : <a href="../Utils/RngMap/module-type-S/index.html">Utils.RngMap.S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../Utils/RngMap/module-type-S/index.html#type-obj">obj</a> = <a href="#type-field">field</a></span></span></code></div><div class="spec-doc"><p>A range map over field to represent a structure layout</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-struc"><a href="#type-struc" class="anchor"></a><code><span><span class="keyword">type</span> struc</span><span> = </span><span>{</span></code><ol><li id="type-struc.layout" class="def record field anchored"><a href="#type-struc.layout" class="anchor"></a><code><span>layout : <a href="FieldMap/index.html#type-t">FieldMap.t</a>;</span></code></li><li id="type-struc.name" class="def record field anchored"><a href="#type-struc.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-struc.size" class="def record field anchored"><a href="#type-struc.size" class="anchor"></a><code><span>size : int;</span></code></li><li id="type-struc.complete" class="def record field anchored"><a href="#type-struc.complete" class="anchor"></a><code><span>complete : bool;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type of a C structure.</p><p>A structure can be complete or incomplete but due to some internal hackery this is a need for a subtle difference with C: Even incomplete structure have a size, they just don't have any field.</p><p>A incomplete struct can and will often be complete later as the interpretation of DWARF information advances.</p><p>The name field is the linking name of the struct.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = </span><span>{</span></code><ol><li id="type-enum.name" class="def record field anchored"><a href="#type-enum.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-enum.labels" class="def record field anchored"><a href="#type-enum.labels" class="anchor"></a><code><span>labels : <span><span>(int, <span>string option</span>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The representation type of a C enumeration</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-cupdie_id"><a href="#type-cupdie_id" class="anchor"></a><code><span><span class="keyword">type</span> cupdie_id</span><span> = int * int</span></code></div><div class="spec-doc"><p>The identifier for a linksem_cupdie. See <a href="#val-ids_of_cupdie"><code>ids_of_cupdie</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_env"><a href="#type-linksem_env" class="anchor"></a><code><span><span class="keyword">type</span> linksem_env</span><span> = <span><a href="#type-linksem_t">linksem_t</a> list</span></span></code></div><div class="spec-doc"><p>The type of environement linksem gives us.</p><p>Only structs, enums and unions can appear. A type can appear multiple times and also be forward-declared with missing data like size. <a href="#val-env_of_linksem"><code>env_of_linksem</code></a> hopefully deals with all those problems</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_indexed_env"><a href="#type-linksem_indexed_env" class="anchor"></a><code><span><span class="keyword">type</span> linksem_indexed_env</span><span> = <span><span>(<a href="#type-cupdie_id">cupdie_id</a>, <a href="#type-linksem_t">linksem_t</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span></span></code></div><div class="spec-doc"><p>An version of the linksem environement indexed by <a href="#type-cupdie_id"><code>cupdie_id</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-env"><a href="#type-env" class="anchor"></a><code><span><span class="keyword">type</span> env</span><span> = </span><span>{</span></code><ol><li id="type-env.structs" class="def record field anchored"><a href="#type-env.structs" class="anchor"></a><code><span>structs : <span><span>(string, <a href="#type-struc">struc</a>)</span> <a href="../Utils/IdMap/index.html#type-t">Utils.IdMap.t</a></span>;</span></code></li><li id="type-env.enums" class="def record field anchored"><a href="#type-env.enums" class="anchor"></a><code><span>enums : <span><span>(string, <a href="#type-enum">enum</a>)</span> <a href="../Utils/IdMap/index.html#type-t">Utils.IdMap.t</a></span>;</span></code></li><li id="type-env.lenv" class="def record field anchored"><a href="#type-env.lenv" class="anchor"></a><code><span>lenv : <a href="#type-linksem_indexed_env">linksem_indexed_env</a>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type environment that contain mapping from linking name and a generated id</p><p>to the actual content of structs and enumerations.</p><p>Linking names can be:</p><ul><li>A plain name for a struct/enum declared with a tag.</li><li><code>typedef.name</code> for an unnamed struct declared in a typedef</li><li><code>outer.member</code> for unnamed struct used as the type of a <code>member</code> of a struct with linking name <code>outer</code>.</li></ul><p>As an unnamed struct can be declared in the linksem environement but used with the typedef only after the initial environement setup of <a href="#val-env_of_linksem"><code>env_of_linksem</code></a>, the original linksem type must be kept alive in <code>lenv</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ptr_size"><a href="#val-ptr_size" class="anchor"></a><code><span><span class="keyword">val</span> ptr_size : int</span></code></div><div class="spec-doc"><p>The size of pointer. This will be configurable later</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enum_size"><a href="#val-enum_size" class="anchor"></a><code><span><span class="keyword">val</span> enum_size : int</span></code></div><div class="spec-doc"><p>The size of enums. This will be configurable later</p></div></div><h2 id="comparisons"><a href="#comparisons" class="anchor"></a>Comparisons</h2><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><h2 id="convenience-manipulation"><a href="#convenience-manipulation" class="anchor"></a>Convenience manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-is_struct"><a href="#val-is_struct" class="anchor"></a><code><span><span class="keyword">val</span> is_struct : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_array"><a href="#val-is_array" class="anchor"></a><code><span><span class="keyword">val</span> is_array : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_ptr"><a href="#val-is_ptr" class="anchor"></a><code><span><span class="keyword">val</span> is_ptr : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_scalar"><a href="#val-is_scalar" class="anchor"></a><code><span><span class="keyword">val</span> is_scalar : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_composite"><a href="#val-is_composite" class="anchor"></a><code><span><span class="keyword">val</span> is_composite : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_constexpr"><a href="#val-is_constexpr" class="anchor"></a><code><span><span class="keyword">val</span> is_constexpr : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ptr"><a href="#val-ptr" class="anchor"></a><code><span><span class="keyword">val</span> ptr : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-unqualified">unqualified</a></span></code></div><div class="spec-doc"><p>Make a simple pointer from a type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-voidstar"><a href="#val-voidstar" class="anchor"></a><code><span><span class="keyword">val</span> voidstar : <a href="#type-unqualified">unqualified</a></span></code></div><div class="spec-doc"><p>A void* pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-qual"><a href="#val-qual" class="anchor"></a><code><span><span class="keyword">val</span> qual : 
+  <span><span class="optlabel">?const</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?volatile</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?restrict</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?constexpr</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-unqualified">unqualified</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a qualified type from an unqualified type with the specified qualifiers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_qual"><a href="#val-add_qual" class="anchor"></a><code><span><span class="keyword">val</span> add_qual : 
+  <span><span class="optlabel">?const</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?volatile</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?restrict</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?constexpr</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>update specified qualifiers. Other qualifier are kept</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-machine"><a href="#val-machine" class="anchor"></a><code><span><span class="keyword">val</span> machine : <span><span class="optlabel">?constexpr</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a machine type of that size without qualifiers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_frag"><a href="#val-of_frag" class="anchor"></a><code><span><span class="keyword">val</span> of_frag : 
+  <span><span class="optlabel">?provenance</span>:<a href="#type-provenance">provenance</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?offset</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?constexpr</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?restrict</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-fragment">fragment</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a pointer to fragment with specified offset (0 by default)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_frag_somewhere"><a href="#val-of_frag_somewhere" class="anchor"></a><code><span><span class="keyword">val</span> of_frag_somewhere : 
+  <span><span class="optlabel">?provenance</span>:<a href="#type-provenance">provenance</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?constexpr</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?restrict</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-fragment">fragment</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a pointer to fragment Somewhere</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-incomplete_struct"><a href="#val-incomplete_struct" class="anchor"></a><code><span><span class="keyword">val</span> incomplete_struct : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-struc">struc</a></span></code></div><div class="spec-doc"><p>Build an incomplete struct with a linking name and a size</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make_env"><a href="#val-make_env" class="anchor"></a><code><span><span class="keyword">val</span> make_env : <span><a href="#type-linksem_indexed_env">linksem_indexed_env</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-env">env</a></span></code></div><div class="spec-doc"><p>Makes an empty environement from and indexed linksem environement</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-offset_update"><a href="#val-offset_update" class="anchor"></a><code><span><span class="keyword">val</span> offset_update : <span><a href="#type-offset">offset</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-offset">offset</a></span></code></div><div class="spec-doc"><p>Update an <a href="#type-field.offset"><code>offset</code></a> with an integer update</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ptr_update"><a href="#val-ptr_update" class="anchor"></a><code><span><span class="keyword">val</span> ptr_update : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Update an pointer with an integer update</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ptr_set"><a href="#val-ptr_set" class="anchor"></a><code><span><span class="keyword">val</span> ptr_set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Set a arbitrary new offset in a pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ptr_forget"><a href="#val-ptr_forget" class="anchor"></a><code><span><span class="keyword">val</span> ptr_forget : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Make a pointer forget it's offset</p></div></div><h2 id="sizeof"><a href="#sizeof" class="anchor"></a>Sizeof</h2><p>This section give implementation of sizeof function.</p><p>Dynamic array have size 0 until we are able to deal with C99 last member dynamic arrays. This will mess up with <a href="#val-type_at"><code>type_at</code></a>. TODO fix it.</p><div class="odoc-spec"><div class="spec value anchored" id="val-sizeof_unqualified"><a href="#val-sizeof_unqualified" class="anchor"></a><code><span><span class="keyword">val</span> sizeof_unqualified : <span><a href="#type-unqualified">unqualified</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Give the size of an <a href="#type-t.unqualified"><code>unqualified</code></a> type. Need the environement.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sizeof"><a href="#val-sizeof" class="anchor"></a><code><span><span class="keyword">val</span> sizeof : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Give the size of an type. Need the environement.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>For being used in <code>RngMap.LenObject</code></p></div></div><h2 id="ctyplink"><a href="#ctyplink" class="anchor"></a>C type linking: From Linksem</h2><p>This section contain the whole hierarchy of function used to convert type from DWARF representation to the internal type system.</p><p>During this conversion, C type linking happens. This means that structure with the same name from different compilation unit are identified as being the same. If they do not have the same layout, an error is raised. This would mean that either the C program does very weird thing with it's type that we don't want to verify or more likely that it is ill-formed. As we have to deal with anonymous struct, name are a bit more complex than plain <code>struct</code> tags. See <a href="#type-conversion_context.env"><code>env</code></a> for a description.</p><p>The top-level interface for types is <a href="#val-of_linksem"><code>of_linksem</code></a> and the top-level interface for environement is <a href="#val-env_of_linksem"><code>env_of_linksem</code></a>. Those will be called by <a href="../Dw/index.html"><code>Dw</code></a> at DWARF loading time to generate a coherent type system.</p><div class="odoc-spec"><div class="spec type anchored" id="type-conversion_context"><a href="#type-conversion_context" class="anchor"></a><code><span><span class="keyword">type</span> conversion_context</span><span> = </span><span>{</span></code><ol><li id="type-conversion_context.env" class="def record field anchored"><a href="#type-conversion_context.env" class="anchor"></a><code><span>env : <a href="#type-env">env</a>;</span></code></li><li id="type-conversion_context.potential_link_name" class="def record field anchored"><a href="#type-conversion_context.potential_link_name" class="anchor"></a><code><span>potential_link_name : <span>string option</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>This type is a conversion context.</p><p>Its role is to contain all the things that all the functions in this section will need to convert types.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ids_of_cupdie"><a href="#val-ids_of_cupdie" class="anchor"></a><code><span><span class="keyword">val</span> ids_of_cupdie : <span><span class="xref-unresolved">Dwarf</span>.cupdie <span class="arrow">&#45;&gt;</span></span> <a href="#type-cupdie_id">cupdie_id</a></span></code></div><div class="spec-doc"><p>Get the id of a linksem <code>cupdie</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_decl"><a href="#val-pp_decl" class="anchor"></a><code><span><span class="keyword">val</span> pp_decl : <span><span class="xref-unresolved">Dwarf</span>.decl <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the dwarf decl type</p><p>TODO: Move that in the appropriate place</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-LinkError"><a href="#exception-LinkError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">LinkError</span></span></code></div><div class="spec-doc"><p>This exception is raised when the type we are trying to reach must came from another translation unit or later in the current one.</p><p>The information is incomplete at this moment to create is.</p><p>Normally this exception should only happen during the initial <a href="#val-env_of_linksem"><code>env_of_linksem</code></a>. If it happens elsewhere, either the code used an anonymous struct that do not have C++-like linkage or the compiler did not do its job.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_some_link"><a href="#val-expect_some_link" class="anchor"></a><code><span><span class="keyword">val</span> expect_some_link : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-base_type_of_linksem"><a href="#val-base_type_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> base_type_of_linksem : 
+  <span><span class="optlabel">?size</span>:<span class="xref-unresolved">Sym_ocaml</span>.Num.t <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">encoding</span>:<span class="xref-unresolved">Sym_ocaml</span>.Num.t <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-unqualified">unqualified</a></span></code></div><div class="spec-doc"><p>Convert a base type with a name and encoding and maybe a size to its inner representation</p><p>Only integers, chars and bools supported. No floating points</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-field_of_linksem"><a href="#val-field_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> field_of_linksem : <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_field">linksem_field</a> <span class="arrow">&#45;&gt;</span></span> <a href="FieldMap/index.html#type-obj">FieldMap.obj</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-field_map_of_linksem"><a href="#val-field_map_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> field_map_of_linksem : 
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-linksem_field">linksem_field</a> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="FieldMap/index.html#type-t">FieldMap.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-struc_of_linksem"><a href="#val-struc_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> struc_of_linksem : 
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-linksem_field">linksem_field</a> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-struc">struc</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-struct_type_of_linksem"><a href="#val-struct_type_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> struct_type_of_linksem : 
+  <span><span class="optlabel">?force_complete</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">cupdie</span>:<span class="xref-unresolved">Dwarf</span>.cupdie <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">mname</span>:<span>string option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">decl</span>:<span class="xref-unresolved">Dwarf</span>.decl <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-unqualified">unqualified</a></span></code></div><div class="spec-doc"><p>Build a struct from it's cupdie and name. If <code>force_complete</code> is true and the struct is incomplete. It will try to complete is using <code>cupdie</code> and throw <a href="#exception-LinkError"><code>LinkError</code></a> if it fails.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enum_of_linksem"><a href="#val-enum_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> enum_of_linksem : 
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="xref-unresolved">Dwarf</span>.enumeration_member list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-enum">enum</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enum_type_of_linksem"><a href="#val-enum_type_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> enum_type_of_linksem : 
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">cupdie</span>:<span class="xref-unresolved">Dwarf</span>.cupdie <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">mname</span>:<span>string option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">decl</span>:<span class="xref-unresolved">Dwarf</span>.decl <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-unqualified">unqualified</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unqualified_of_linksem"><a href="#val-unqualified_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> unqualified_of_linksem : 
+  <span><span class="optlabel">?force_complete</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-unqualified">unqualified</a></span></code></div><div class="spec-doc"><p>Convert an unqualified type. Union are just <code>Machine n</code> where n is their size</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem_none"><a href="#val-of_linksem_none" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem_none : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Placeholder for whatever the right thing to do is when linksem found no type - TODO: fix</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem_cc"><a href="#val-of_linksem_cc" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem_cc : 
+  <span><span class="optlabel">?force_complete</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">cc</span>:<a href="#type-conversion_context">conversion_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?const</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?volatile</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?restrict</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The main <code>of_linksem</code> that take a full conversion_context and qualifiers.</p><p>The user friendly version is <a href="#val-of_linksem"><code>of_linksem</code></a></p><p>See <a href="#val-struct_type_of_linksem"><code>struct_type_of_linksem</code></a> for the explanation of <code>force_complete</code>.</p><p>All the qualifier passed as parameter are added to the resulting type.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><span class="label">env</span>:<a href="#type-env">env</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The user friendly interface that convert a type using the environment. This useful when there is no additional linking information to pass on</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-env_of_linksem"><a href="#val-env_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> env_of_linksem : <span><a href="#type-linksem_env">linksem_env</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-env">env</a></span></code></div><div class="spec-doc"><p>The main environment conversion function.</p><p>This the function that deal with all the type linking process, forward declaration an all that stuff.</p><p>First it create the indexed linksem environment (member lenv of <a href="#type-conversion_context.env"><code>env</code></a>),</p><p>Then it registers all named structs as incomplete in the environment (to deal with self recursion, only named structs can self-recurse).</p><p>Finally it run <a href="#val-of_linksem_cc"><code>of_linksem_cc</code></a> on all the types with <code>force_complete</code> on. During this phase it ignore all <a href="#exception-LinkError"><code>LinkError</code></a> that arise. It assumes that if some thing was incomplete at that point, it will become complete later.</p><p>Then it can return the freshly built environment.</p><p>If some structs are still incomplete, but are actually used, the <a href="#exception-LinkError"><code>LinkError</code></a> will be raised at the time of use.</p></div></div><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp_signed"><a href="#val-pp_signed" class="anchor"></a><code><span><span class="keyword">val</span> pp_signed : <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a type. If an environement is provided, structs and enums will be printed with a name, otherwise they will just have a number</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unqualified"><a href="#val-pp_unqualified" class="anchor"></a><code><span><span class="keyword">val</span> pp_unqualified : <span><a href="#type-unqualified">unqualified</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_fragment"><a href="#val-pp_fragment" class="anchor"></a><code><span><span class="keyword">val</span> pp_fragment : <span><a href="#type-fragment">fragment</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_offset"><a href="#val-pp_offset" class="anchor"></a><code><span><span class="keyword">val</span> pp_offset : <span><a href="#type-offset">offset</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_arr"><a href="#val-pp_arr" class="anchor"></a><code><span><span class="keyword">val</span> pp_arr : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span>int option</span> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_arr_dim"><a href="#val-pp_arr_dim" class="anchor"></a><code><span><span class="keyword">val</span> pp_arr_dim : <span><span>int option</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_field"><a href="#val-pp_field" class="anchor"></a><code><span><span class="keyword">val</span> pp_field : <span><a href="#type-field">field</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_struct"><a href="#val-pp_struct" class="anchor"></a><code><span><span class="keyword">val</span> pp_struct : <span><a href="#type-struc">struc</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enums"><a href="#val-pp_enums" class="anchor"></a><code><span><span class="keyword">val</span> pp_enums : <span><a href="#type-enum">enum</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_env"><a href="#val-pp_env" class="anchor"></a><code><span><span class="keyword">val</span> pp_env : <span><a href="#type-env">env</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Print the whole environement (not the linksem indexed environment)</p></div></div><h2 id="type-at"><a href="#type-at" class="anchor"></a>Type at</h2><p>This section is about getting the type at a specific offset in things.</p><div class="odoc-spec"><div class="spec value anchored" id="val-struct_at"><a href="#val-struct_at" class="anchor"></a><code><span><span class="keyword">val</span> struct_at : <span><span class="label">env</span>:<a href="#type-env">env</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-struc">struc</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <a href="../Utils/Option/index.html#type-t">Utils.Option.t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-type_at"><code>type_at</code></a> but for structs</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_at"><a href="#val-type_at" class="anchor"></a><code><span><span class="keyword">val</span> type_at : <span><span class="label">env</span>:<a href="#type-env">env</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <a href="../Utils/Option/index.html#type-t">Utils.Option.t</a></span></span></code></div><div class="spec-doc"><p>Get the type of size <code>size</code> at the provided offset in another type</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Dw/Func/index.html b/doc/html/read-dwarf/Dw/Func/index.html
index 3f539ef4..5c97503e 100644
--- a/doc/html/read-dwarf/Dw/Func/index.html
+++ b/doc/html/read-dwarf/Dw/Func/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Func (read-dwarf.Dw.Func)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Dw</a> &#x00BB; Func</nav><h1>Module <code>Dw.Func</code></h1><p>This module contain all the definition to handle functions as defined in the DWARF information of the target file</p></header><dl><dt class="spec type" id="type-func"><a href="#type-func" class="anchor"></a><code><span class="keyword">type</span> func</code><code> = </code><code>{</code><table class="record"><tr id="type-func.name" class="anchored"><td class="def field"><a href="#type-func.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-func.scope" class="anchored"><td class="def field"><a href="#type-func.scope" class="anchor"></a><code>scope : <a href="index.html#type-scope">scope</a>;</code></td></tr><tr id="type-func.ret" class="anchored"><td class="def field"><a href="#type-func.ret" class="anchor"></a><code>ret : <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> option</span>;</code></td></tr></table><code>}</code></dt><dd><p>Type of a dwarf function that may or may not be inlined</p><p>If this type stand on its own, then it is inlined. If it is inside a <a href="index.html#type-t"><code>t</code></a> then it's a top level function. There is no separate type for inline functions because they do not have any special data that a top level function may not have</p></dd></dl><dl><dt class="spec type" id="type-scope"><a href="#type-scope" class="anchor"></a><code><span class="keyword">and</span> scope</code><code> = </code><code>{</code><table class="record"><tr id="type-scope.vars" class="anchored"><td class="def field"><a href="#type-scope.vars" class="anchor"></a><code>vars : <span><a href="../Var/index.html#type-t">Var.t</a> list</span>;</code></td></tr><tr id="type-scope.funcs" class="anchored"><td class="def field"><a href="#type-scope.funcs" class="anchor"></a><code>funcs : <span><a href="index.html#type-func">func</a> list</span>;</code></td></tr><tr id="type-scope.scopes" class="anchored"><td class="def field"><a href="#type-scope.scopes" class="anchor"></a><code>scopes : <span><a href="index.html#type-scope">scope</a> list</span>;</code></td></tr></table><code>}</code></dt><dd><p>Type of a dwarf scope that may contain recursively other data. The lists here have the semantic meaning of sets: the order is irrelevant.</p></dd></dl><dl><dt class="spec type" id="type-linksem_func"><a href="#type-linksem_func" class="anchor"></a><code><span class="keyword">type</span> linksem_func</code><code> = Dwarf.sdt_subroutine</code></dt><dd><p>This is the type a dwarf function in linksem</p></dd></dl><dl><dt class="spec type" id="type-linksem_scope"><a href="#type-linksem_scope" class="anchor"></a><code><span class="keyword">type</span> linksem_scope</code><code> = Dwarf.sdt_lexical_block</code></dt><dd><p>This is the type a dwarf scope in linksem</p></dd></dl><dl><dt class="spec value" id="val-func_of_linksem"><a href="#val-func_of_linksem" class="anchor"></a><code><span class="keyword">val</span> func_of_linksem : <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="../../Ctype/index.html#type-env">Ctype.env</a> <span>&#45;&gt;</span> <a href="index.html#type-linksem_func">linksem_func</a> <span>&#45;&gt;</span> <a href="index.html#type-func">func</a></code></dt><dd><p>Create a Dwarf function from its linksem counterpart</p></dd></dl><dl><dt class="spec value" id="val-scope_of_linksem"><a href="#val-scope_of_linksem" class="anchor"></a><code><span class="keyword">val</span> scope_of_linksem : <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="../../Ctype/index.html#type-env">Ctype.env</a> <span>&#45;&gt;</span> <a href="index.html#type-linksem_scope">linksem_scope</a> <span>&#45;&gt;</span> <a href="index.html#type-scope">scope</a></code></dt><dd><p>Create and Dwarf scope from its linksem counterpart</p></dd></dl><dl><dt class="spec value" id="val-func_get_api"><a href="#val-func_get_api" class="anchor"></a><code><span class="keyword">val</span> func_get_api : <a href="index.html#type-func">func</a> <span>&#45;&gt;</span> <a href="../../Arch/index.html#type-func_api">Arch.func_api</a></code></dt><dd><p>Get the API of the function</p></dd></dl><dl><dt class="spec value" id="val-pp_raw_func"><a href="#val-pp_raw_func" class="anchor"></a><code><span class="keyword">val</span> pp_raw_func : <a href="index.html#type-func">func</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.OCaml.representation</code></dt><dt class="spec value" id="val-pp_raw_scope"><a href="#val-pp_raw_scope" class="anchor"></a><code><span class="keyword">val</span> pp_raw_scope : <a href="index.html#type-scope">scope</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.OCaml.representation</code></dt></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.sym" class="anchored"><td class="def field"><a href="#type-t.sym" class="anchor"></a><code>sym : <span><a href="../../Elf/Symbol/index.html#type-t">Elf.Symbol.t</a> option</span>;</code></td></tr><tr id="type-t.func" class="anchored"><td class="def field"><a href="#type-t.func" class="anchor"></a><code>func : <a href="index.html#type-func">func</a>;</code></td></tr></table><code>}</code></dt><dd><p>This the type of a top-level function. It may have an associated elf symbol</p><p>This type will contain all necessary indexes for function-wide fast access to relevant dwarf information.</p></dd></dl><dl><dt class="spec type" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span class="keyword">type</span> linksem_t</code><code> = Dwarf.sdt_subroutine</code></dt><dd><p>This is the type a dwarf top_level function in linksem</p></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="../../Ctype/index.html#type-env">Ctype.env</a> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a dwarf top level function from its Linksem counterpart. The ELF file is to get a potential matching symbol. For now the matching is made with name and then code address, but perhaps the code using this should be rephrased in terms of addresses instead of symbols, to be more resilient</p></dd></dl><dl><dt class="spec value" id="val-get_api"><a href="#val-get_api" class="anchor"></a><code><span class="keyword">val</span> get_api : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Arch/index.html#type-func_api">Arch.func_api</a></code></dt><dd><p>Get the API of a top level function</p></dd></dl><dl><dt class="spec value" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span class="keyword">val</span> pp_raw : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a raw top level function</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Func (read-dwarf.Dw.Func)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Dw</a> &#x00BB; Func</nav><header class="odoc-preamble"><h1>Module <code><span>Dw.Func</span></code></h1><p>This module contain all the definition to handle functions as defined in the DWARF information of the target file</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-func"><a href="#type-func" class="anchor"></a><code><span><span class="keyword">type</span> func</span><span> = </span><span>{</span></code><ol><li id="type-func.name" class="def record field anchored"><a href="#type-func.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-func.scope" class="def record field anchored"><a href="#type-func.scope" class="anchor"></a><code><span>scope : <a href="#type-scope">scope</a>;</span></code></li><li id="type-func.ret" class="def record field anchored"><a href="#type-func.ret" class="anchor"></a><code><span>ret : <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> option</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Type of a dwarf function that may or may not be inlined</p><p>If this type stand on its own, then it is inlined. If it is inside a <a href="#type-t"><code>t</code></a> then it's a top level function. There is no separate type for inline functions because they do not have any special data that a top level function may not have</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-scope"><a href="#type-scope" class="anchor"></a><code><span><span class="keyword">and</span> scope</span><span> = </span><span>{</span></code><ol><li id="type-scope.vars" class="def record field anchored"><a href="#type-scope.vars" class="anchor"></a><code><span>vars : <span><a href="../Var/index.html#type-t">Var.t</a> list</span>;</span></code></li><li id="type-scope.funcs" class="def record field anchored"><a href="#type-scope.funcs" class="anchor"></a><code><span>funcs : <span><a href="#type-func">func</a> list</span>;</span></code></li><li id="type-scope.scopes" class="def record field anchored"><a href="#type-scope.scopes" class="anchor"></a><code><span>scopes : <span><a href="#type-scope">scope</a> list</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Type of a dwarf scope that may contain recursively other data. The lists here have the semantic meaning of sets: the order is irrelevant.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_func"><a href="#type-linksem_func" class="anchor"></a><code><span><span class="keyword">type</span> linksem_func</span><span> = <span class="xref-unresolved">Dwarf</span>.sdt_subroutine</span></code></div><div class="spec-doc"><p>This is the type a dwarf function in linksem</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_scope"><a href="#type-linksem_scope" class="anchor"></a><code><span><span class="keyword">type</span> linksem_scope</span><span> = <span class="xref-unresolved">Dwarf</span>.sdt_lexical_block</span></code></div><div class="spec-doc"><p>This is the type a dwarf scope in linksem</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-func_of_linksem"><a href="#val-func_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> func_of_linksem : <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-env">Ctype.env</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_func">linksem_func</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-func">func</a></span></code></div><div class="spec-doc"><p>Create a Dwarf function from its linksem counterpart</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scope_of_linksem"><a href="#val-scope_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> scope_of_linksem : <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-env">Ctype.env</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_scope">linksem_scope</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-scope">scope</a></span></code></div><div class="spec-doc"><p>Create and Dwarf scope from its linksem counterpart</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-func_get_api"><a href="#val-func_get_api" class="anchor"></a><code><span><span class="keyword">val</span> func_get_api : <span><a href="#type-func">func</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Arch/index.html#type-func_api">Arch.func_api</a></span></code></div><div class="spec-doc"><p>Get the API of the function</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_func"><a href="#val-pp_raw_func" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_func : <span><a href="#type-func">func</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_scope"><a href="#val-pp_raw_scope" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_scope : <span><a href="#type-scope">scope</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.sym" class="def record field anchored"><a href="#type-t.sym" class="anchor"></a><code><span>sym : <span><a href="../../Elf/Symbol/index.html#type-t">Elf.Symbol.t</a> option</span>;</span></code></li><li id="type-t.func" class="def record field anchored"><a href="#type-t.func" class="anchor"></a><code><span>func : <a href="#type-func">func</a>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>This the type of a top-level function. It may have an associated elf symbol</p><p>This type will contain all necessary indexes for function-wide fast access to relevant dwarf information.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span><span class="keyword">type</span> linksem_t</span><span> = <span class="xref-unresolved">Dwarf</span>.sdt_subroutine</span></code></div><div class="spec-doc"><p>This is the type a dwarf top_level function in linksem</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-env">Ctype.env</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a dwarf top level function from its Linksem counterpart. The ELF file is to get a potential matching symbol. For now the matching is made with name and then code address, but perhaps the code using this should be rephrased in terms of addresses instead of symbols, to be more resilient</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_api"><a href="#val-get_api" class="anchor"></a><code><span><span class="keyword">val</span> get_api : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Arch/index.html#type-func_api">Arch.func_api</a></span></code></div><div class="spec-doc"><p>Get the API of a top level function</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a raw top level function</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Dw/Loc/index.html b/doc/html/read-dwarf/Dw/Loc/index.html
index dacbb921..b6774946 100644
--- a/doc/html/read-dwarf/Dw/Loc/index.html
+++ b/doc/html/read-dwarf/Dw/Loc/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Loc (read-dwarf.Dw.Loc)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Dw</a> &#x00BB; Loc</nav><h1>Module <code>Dw.Loc</code></h1><p>This module represent architectural locations. Locations in DWARF information are represented as a little stack language (represented as <a href="index.html#type-dwop"><code>dwop</code></a><code> list</code>) which describes how to compute the target value from the current concrete state. This computation can be arbitrarily complex, for example take half of the value from the high bits of a register and then the other half from memory at a specific address coming from another register.</p><p>Those expression are not directly usable to guide the type inference, as we would much more like simple direct information like &quot;This value is in that register&quot;. To solve this, there is a custom type <a href="index.html#type-t"><code>t</code></a> that interpret simple static locations directly and leaves more complex location uninterpreted.</p><p>This interpretation is currently very basic. It remains to be seen if it actually need to be improved.</p></header><dl><dt class="spec type" id="type-dwop"><a href="#type-dwop" class="anchor"></a><code><span class="keyword">type</span> dwop</code><code> = Dwarf.operation</code></dt><dd><p>The type of a dwarf location stack operation</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.Register" class="anchored"><td class="def constructor"><a href="#type-t.Register" class="anchor"></a><code>| </code><code><span class="constructor">Register</span> <span class="keyword">of</span> <a href="../../State/Reg/index.html#type-t">State.Reg.t</a></code></td><td class="doc"><p>In the register</p></td></tr><tr id="type-t.RegisterOffset" class="anchored"><td class="def constructor"><a href="#type-t.RegisterOffset" class="anchor"></a><code>| </code><code><span class="constructor">RegisterOffset</span> <span class="keyword">of</span> <a href="../../State/Reg/index.html#type-t">State.Reg.t</a> * int</code></td><td class="doc"><p>At register + offset address</p></td></tr><tr id="type-t.StackFrame" class="anchored"><td class="def constructor"><a href="#type-t.StackFrame" class="anchor"></a><code>| </code><code><span class="constructor">StackFrame</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>On the stackFrame with offset</p></td></tr><tr id="type-t.Global" class="anchored"><td class="def constructor"><a href="#type-t.Global" class="anchor"></a><code>| </code><code><span class="constructor">Global</span> <span class="keyword">of</span> <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a></code></td><td class="doc"><p>Global variable with an offset</p></td></tr><tr id="type-t.Dwarf" class="anchored"><td class="def constructor"><a href="#type-t.Dwarf" class="anchor"></a><code>| </code><code><span class="constructor">Dwarf</span> <span class="keyword">of</span> <span><a href="index.html#type-dwop">dwop</a> list</span></code></td><td class="doc"><p>Uninterpreted dwarf location</p></td></tr></table></dt><dd><p>The type of a location, as static as possible</p></dd></dl><dl><dt class="spec type" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span class="keyword">type</span> linksem_t</code><code> = <span><a href="index.html#type-dwop">dwop</a> list</span></code></dt><dd><p>The type of a location in linksem format</p></dd></dl><dl><dt class="spec value" id="val-vDW_OP_addr"><a href="#val-vDW_OP_addr" class="anchor"></a><code><span class="keyword">val</span> vDW_OP_addr : int</code></dt><dd><p>The integer value of the DW_OP_addr constant in DWARF standard</p><p>TODO this should come from LinkSem's dwarf</p></dd></dl><dl><dt class="spec value" id="val-vDW_OP_reg0"><a href="#val-vDW_OP_reg0" class="anchor"></a><code><span class="keyword">val</span> vDW_OP_reg0 : int</code></dt><dd><p>The integer value of the DW_OP_reg0 constant in DWARF standard</p></dd></dl><dl><dt class="spec value" id="val-vDW_OP_breg0"><a href="#val-vDW_OP_breg0" class="anchor"></a><code><span class="keyword">val</span> vDW_OP_breg0 : int</code></dt><dd><p>The integer value of the DW_OP_breg0 constant in DWARF standard</p></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : <span>?&#8288;amap:<a href="../../Arch/index.html#type-dwarf_reg_map">Arch.dwarf_reg_map</a></span> <span>&#45;&gt;</span> <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert a linksem location description into a <a href="index.html#type-t"><code>Loc.t</code></a></p><p>Very naive for now : If the list has a single element that we can translate directly, we do. Otherwise, we dump it into the <a href="index.html#type-t.Dwarf"><code>t.Dwarf</code></a> constructor</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert the location to a string. This is not reversible</p></dd></dl><dl><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Compare two location. Loc.t is not compatible with polymorphic compare</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty-print the location</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Loc (read-dwarf.Dw.Loc)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Dw</a> &#x00BB; Loc</nav><header class="odoc-preamble"><h1>Module <code><span>Dw.Loc</span></code></h1><p>This module represent architectural locations. Locations in DWARF information are represented as a little stack language (represented as <a href="#type-dwop"><code>dwop</code></a><code> list</code>) which describes how to compute the target value from the current concrete state. This computation can be arbitrarily complex, for example take half of the value from the high bits of a register and then the other half from memory at a specific address coming from another register.</p><p>Those expression are not directly usable to guide the type inference, as we would much more like simple direct information like &quot;This value is in that register&quot;. To solve this, there is a custom type <a href="#type-t"><code>t</code></a> that interpret simple static locations directly and leaves more complex location uninterpreted.</p><p>This interpretation is currently very basic. It remains to be seen if it actually need to be improved.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-dwop"><a href="#type-dwop" class="anchor"></a><code><span><span class="keyword">type</span> dwop</span><span> = <span class="xref-unresolved">Dwarf</span>.operation</span></code></div><div class="spec-doc"><p>The type of a dwarf location stack operation</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.Register" class="def variant constructor anchored"><a href="#type-t.Register" class="anchor"></a><code><span>| </span><span><span class="constructor">Register</span> <span class="keyword">of</span> <a href="../../State/Reg/index.html#type-t">State.Reg.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>In the register</p><span class="comment-delim">*)</span></div></li><li id="type-t.RegisterOffset" class="def variant constructor anchored"><a href="#type-t.RegisterOffset" class="anchor"></a><code><span>| </span><span><span class="constructor">RegisterOffset</span> <span class="keyword">of</span> <a href="../../State/Reg/index.html#type-t">State.Reg.t</a> * int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>At register + offset address</p><span class="comment-delim">*)</span></div></li><li id="type-t.StackFrame" class="def variant constructor anchored"><a href="#type-t.StackFrame" class="anchor"></a><code><span>| </span><span><span class="constructor">StackFrame</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>On the stackFrame with offset</p><span class="comment-delim">*)</span></div></li><li id="type-t.Global" class="def variant constructor anchored"><a href="#type-t.Global" class="anchor"></a><code><span>| </span><span><span class="constructor">Global</span> <span class="keyword">of</span> <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Global variable with an offset</p><span class="comment-delim">*)</span></div></li><li id="type-t.Const" class="def variant constructor anchored"><a href="#type-t.Const" class="anchor"></a><code><span>| </span><span><span class="constructor">Const</span> <span class="keyword">of</span> <a href="../../Utils/Sym/index.html#type-t">Utils.Sym.t</a></span></code></li><li id="type-t.Dwarf" class="def variant constructor anchored"><a href="#type-t.Dwarf" class="anchor"></a><code><span>| </span><span><span class="constructor">Dwarf</span> <span class="keyword">of</span> <span><a href="#type-dwop">dwop</a> list</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Uninterpreted dwarf location</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The type of a location, as static as possible</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span><span class="keyword">type</span> linksem_t</span><span> = <span><a href="#type-dwop">dwop</a> list</span></span></code></div><div class="spec-doc"><p>The type of a location in linksem format</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_OP_addr"><a href="#val-vDW_OP_addr" class="anchor"></a><code><span><span class="keyword">val</span> vDW_OP_addr : int</span></code></div><div class="spec-doc"><p>The integer value of the DW_OP_addr constant in DWARF standard</p><p>TODO this should come from LinkSem's dwarf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_OP_reg0"><a href="#val-vDW_OP_reg0" class="anchor"></a><code><span><span class="keyword">val</span> vDW_OP_reg0 : int</span></code></div><div class="spec-doc"><p>The integer value of the DW_OP_reg0 constant in DWARF standard</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vDW_OP_breg0"><a href="#val-vDW_OP_breg0" class="anchor"></a><code><span><span class="keyword">val</span> vDW_OP_breg0 : int</span></code></div><div class="spec-doc"><p>The integer value of the DW_OP_breg0 constant in DWARF standard</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><span class="optlabel">?amap</span>:<a href="../../Arch/index.html#type-dwarf_reg_map">Arch.dwarf_reg_map</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert a linksem location description into a <a href="#type-t"><code>Loc.t</code></a></p><p>Very naive for now : If the list has a single element that we can translate directly, we do. Otherwise, we dump it into the <a href="#type-t.Dwarf"><code>t.Dwarf</code></a> constructor</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert the location to a string. This is not reversible</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Compare two location. Loc.t is not compatible with polymorphic compare</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty-print the location</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Dw/Var/index.html b/doc/html/read-dwarf/Dw/Var/index.html
index 994f650c..5587688d 100644
--- a/doc/html/read-dwarf/Dw/Var/index.html
+++ b/doc/html/read-dwarf/Dw/Var/index.html
@@ -1,2 +1,4 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Dw.Var)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Dw</a> &#x00BB; Var</nav><h1>Module <code>Dw.Var</code></h1><p>This module contain all the definition to handle local and global variables as defined in the DWARF information of the target file</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.name" class="anchored"><td class="def field"><a href="#type-t.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-t.param" class="anchored"><td class="def field"><a href="#type-t.param" class="anchor"></a><code>param : bool;</code></td></tr><tr id="type-t.ctype" class="anchored"><td class="def field"><a href="#type-t.ctype" class="anchor"></a><code>ctype : <a href="../../Ctype/index.html#type-t">Ctype.t</a>;</code></td></tr><tr id="type-t.locs" class="anchored"><td class="def field"><a href="#type-t.locs" class="anchor"></a><code>locs : <span><span>(<span>(int * int)</span> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span>;</code></td></tr></table><code>}</code></dt><dd><p>Type of a DWARF variable</p></dd></dl><dl><dt class="spec type" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span class="keyword">type</span> linksem_t</code><code> = Dwarf.sdt_variable_or_formal_parameter</code></dt><dd><p>Type of a DWARF variable in linksem</p></dd></dl><dl><dt class="spec value" id="val-loc_merge"><a href="#val-loc_merge" class="anchor"></a><code><span class="keyword">val</span> loc_merge : <span><span>(<span>(<span class="type-var">'a</span> * <span class="type-var">'a</span>)</span> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span> <span>&#45;&gt;</span> <span><span>(<span>(<span class="type-var">'a</span> * <span class="type-var">'a</span>)</span> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span></code></dt><dd><p>Merge contiguous location lists</p></dd></dl><dl><dt class="spec value" id="val-clamp_z"><a href="#val-clamp_z" class="anchor"></a><code><span class="keyword">val</span> clamp_z : Z.t <span>&#45;&gt;</span> int</code></dt><dd><p>Convert from Z.t to int, if there is an overflow, returns Int.max_int instead of throwing</p></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="../../Ctype/index.html#type-env">Ctype.env</a> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a DWARF variable from its linksem counterpart</p></dd></dl><dl><dt class="spec value" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span class="keyword">val</span> pp_raw : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a variable</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Dw.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Dw</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Module <code><span>Dw.Var</span></code></h1><p>This module contain all the definition to handle local and global variables as defined in the DWARF information of the target file</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-range"><a href="#type-range" class="anchor"></a><code><span><span class="keyword">type</span> range</span><span> = <a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> * <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.name" class="def record field anchored"><a href="#type-t.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-t.param" class="def record field anchored"><a href="#type-t.param" class="anchor"></a><code><span>param : bool;</span></code></li><li id="type-t.ctype" class="def record field anchored"><a href="#type-t.ctype" class="anchor"></a><code><span>ctype : <a href="../../Ctype/index.html#type-t">Ctype.t</a>;</span></code></li><li id="type-t.locs" class="def record field anchored"><a href="#type-t.locs" class="anchor"></a><code><span>locs : <span><span>(<a href="#type-range">range</a> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span>;</span></code></li><li id="type-t.locs_frame_base" class="def record field anchored"><a href="#type-t.locs_frame_base" class="anchor"></a><code><span>locs_frame_base : <span><span>(<a href="#type-range">range</a> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Type of a DWARF variable</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span><span class="keyword">type</span> linksem_t</span><span> = <span class="xref-unresolved">Dwarf</span>.sdt_variable_or_formal_parameter</span></code></div><div class="spec-doc"><p>Type of a DWARF variable in linksem</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-loc_merge"><a href="#val-loc_merge" class="anchor"></a><code><span><span class="keyword">val</span> loc_merge : 
+  <span><span><span>(<span>(<span class="type-var">'a</span> * <span><span class="type-var">'a</span> option</span>)</span> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span>(<span class="type-var">'a</span> * <span><span class="type-var">'a</span> option</span>)</span> * <a href="../Loc/index.html#type-t">Loc.t</a>)</span> list</span></span></code></div><div class="spec-doc"><p>Merge contiguous location lists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-end_addr_of_sym"><a href="#val-end_addr_of_sym" class="anchor"></a><code><span><span class="keyword">val</span> end_addr_of_sym : <span><a href="../../Utils/Sym/index.html#type-t">Utils.Sym.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-env">Ctype.env</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a DWARF variable from its linksem counterpart</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a variable</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Dw/index.html b/doc/html/read-dwarf/Dw/index.html
index ccfbe564..a32bda2f 100644
--- a/doc/html/read-dwarf/Dw/index.html
+++ b/doc/html/read-dwarf/Dw/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Dw (read-dwarf.Dw)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Dw</nav><h1>Module <code>Dw</code></h1><p>This module provides the specifically interpreted DWARF information needed for read-dwarf operations</p><p>I would have called this module dwarf but linksem decided that is was a good idea to dump all its modules in the global namespace.</p></header><dl><dt class="spec module" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span class="keyword">module</span> <a href="Var/index.html">Var</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module contain all the definition to handle local and global variables as defined in the DWARF information of the target file</p></dd></dl><dl><dt class="spec module" id="module-Func"><a href="#module-Func" class="anchor"></a><code><span class="keyword">module</span> <a href="Func/index.html">Func</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module contain all the definition to handle functions as defined in the DWARF information of the target file</p></dd></dl><dl><dt class="spec module" id="module-Loc"><a href="#module-Loc" class="anchor"></a><code><span class="keyword">module</span> <a href="Loc/index.html">Loc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module represent architectural locations. Locations in DWARF information are represented as a little stack language (represented as <a href="Loc/index.html#type-dwop"><code>dwop</code></a><code> list</code>) which describes how to compute the target value from the current concrete state. This computation can be arbitrarily complex, for example take half of the value from the high bits of a register and then the other half from memory at a specific address coming from another register.</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.elf" class="anchored"><td class="def field"><a href="#type-t.elf" class="anchor"></a><code>elf : <a href="../Elf/File/index.html#type-t">Elf.File.t</a>;</code></td></tr><tr id="type-t.ldwarf" class="anchored"><td class="def field"><a href="#type-t.ldwarf" class="anchor"></a><code>ldwarf : Dwarf.dwarf;</code></td></tr><tr id="type-t.ldwarf_sdt" class="anchored"><td class="def field"><a href="#type-t.ldwarf_sdt" class="anchor"></a><code>ldwarf_sdt : Dwarf.sdt_dwarf;</code></td></tr><tr id="type-t.funcs" class="anchored"><td class="def field"><a href="#type-t.funcs" class="anchor"></a><code>funcs : <span><span>(string, <a href="Func/index.html#type-t">Func.t</a>)</span> Stdlib.Hashtbl.t</span>;</code></td></tr><tr id="type-t.vars" class="anchored"><td class="def field"><a href="#type-t.vars" class="anchor"></a><code>vars : <span><span>(string, <a href="Var/index.html#type-t">Var.t</a>)</span> Stdlib.Hashtbl.t</span>;</code></td></tr><tr id="type-t.tenv" class="anchored"><td class="def field"><a href="#type-t.tenv" class="anchor"></a><code>tenv : <a href="../Ctype/index.html#type-env">Ctype.env</a>;</code></td></tr></table><code>}</code></dt><dd><p>The type that represent a elf-dwarf binary whose information has been fully interpreted</p></dd></dl><dl><dt class="spec exception" id="exception-DwarfError"><a href="#exception-DwarfError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">DwarfError</span> <span class="keyword">of</span> string</code></dt><dd><p>Error on Dwarf parsing</p></dd></dl><dl><dt class="spec value" id="val-dwarferror"><a href="#val-dwarferror" class="anchor"></a><code><span class="keyword">val</span> dwarferror : <span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Throw a <a href="index.html#exception-DwarfError"><code>DwarfError</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_elf"><a href="#val-of_elf" class="anchor"></a><code><span class="keyword">val</span> of_elf : <a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get Dwarf information from an Elf file.</p><p>May raise a <a href="index.html#exception-DwarfError"><code>DwarfError</code></a> if a problem occurs.</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get Dwarf information from an Elf file by name. Use <a href="../Elf/File/index.html#val-of_file"><code>File.of_file</code></a></p></dd></dl><dl><dt class="spec value" id="val-get_func_opt"><a href="#val-get_func_opt" class="anchor"></a><code><span class="keyword">val</span> get_func_opt : <span>name:string</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="Func/index.html#type-t">Func.t</a> option</span></code></dt><dd><p>Get a function by <code>name</code></p></dd></dl><dl><dt class="spec value" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span class="keyword">val</span> pp_raw : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print dwarf data as an ocaml structure</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Dw (read-dwarf.Dw)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Dw</nav><header class="odoc-preamble"><h1>Module <code><span>Dw</span></code></h1><p>This module provides the specifically interpreted DWARF information needed for read-dwarf operations</p><p>I would have called this module dwarf but linksem decided that is was a good idea to dump all its modules in the global namespace.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Var/index.html">Var</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module contain all the definition to handle local and global variables as defined in the DWARF information of the target file</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Func"><a href="#module-Func" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Func/index.html">Func</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module contain all the definition to handle functions as defined in the DWARF information of the target file</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Loc"><a href="#module-Loc" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Loc/index.html">Loc</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module represent architectural locations. Locations in DWARF information are represented as a little stack language (represented as <a href="Loc/index.html#type-dwop"><code>dwop</code></a><code> list</code>) which describes how to compute the target value from the current concrete state. This computation can be arbitrarily complex, for example take half of the value from the high bits of a register and then the other half from memory at a specific address coming from another register.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.elf" class="def record field anchored"><a href="#type-t.elf" class="anchor"></a><code><span>elf : <a href="../Elf/File/index.html#type-t">Elf.File.t</a>;</span></code></li><li id="type-t.ldwarf" class="def record field anchored"><a href="#type-t.ldwarf" class="anchor"></a><code><span>ldwarf : <span class="xref-unresolved">Dwarf</span>.dwarf;</span></code></li><li id="type-t.ldwarf_sdt" class="def record field anchored"><a href="#type-t.ldwarf_sdt" class="anchor"></a><code><span>ldwarf_sdt : <span class="xref-unresolved">Dwarf</span>.sdt_dwarf;</span></code></li><li id="type-t.funcs" class="def record field anchored"><a href="#type-t.funcs" class="anchor"></a><code><span>funcs : <span><span>(string, <a href="Func/index.html#type-t">Func.t</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span>;</span></code></li><li id="type-t.vars" class="def record field anchored"><a href="#type-t.vars" class="anchor"></a><code><span>vars : <span><span>(string, <a href="Var/index.html#type-t">Var.t</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span>;</span></code></li><li id="type-t.tenv" class="def record field anchored"><a href="#type-t.tenv" class="anchor"></a><code><span>tenv : <a href="../Ctype/index.html#type-env">Ctype.env</a>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type that represent a elf-dwarf binary whose information has been fully interpreted</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-DwarfError"><a href="#exception-DwarfError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">DwarfError</span> <span class="keyword">of</span> string</span></code></div><div class="spec-doc"><p>Error on Dwarf parsing</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dwarferror"><a href="#val-dwarferror" class="anchor"></a><code><span><span class="keyword">val</span> dwarferror : <span><span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Throw a <a href="#exception-DwarfError"><code>DwarfError</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_elf"><a href="#val-of_elf" class="anchor"></a><code><span><span class="keyword">val</span> of_elf : <span><a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get Dwarf information from an Elf file.</p><p>May raise a <a href="#exception-DwarfError"><code>DwarfError</code></a> if a problem occurs.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get Dwarf information from an Elf file by name. Use <a href="../Elf/File/index.html#val-of_file"><code>Elf.File.of_file</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_func_opt"><a href="#val-get_func_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_func_opt : <span><span class="label">name</span>:string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Func/index.html#type-t">Func.t</a> option</span></span></code></div><div class="spec-doc"><p>Get a function by <code>name</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print dwarf data as an ocaml structure</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Elf/File/index.html b/doc/html/read-dwarf/Elf/File/index.html
index 6f277bf4..0fcc7c19 100644
--- a/doc/html/read-dwarf/Elf/File/index.html
+++ b/doc/html/read-dwarf/Elf/File/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>File (read-dwarf.Elf.File)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; File</nav><h1>Module <code>Elf.File</code></h1></header><aside><p>This module represent an ELF 64 file. We do not deal with 32 bit ELF files for now The main interesting information is the symbol table.</p></aside><div class="spec module" id="module-SymTbl"><a href="#module-SymTbl" class="anchor"></a><code><span class="keyword">module</span> SymTbl = <a href="../index.html#module-SymTable">SymTable</a></code></div><dl><dt class="spec type" id="type-machine"><a href="#type-machine" class="anchor"></a><code><span class="keyword">type</span> machine</code><code> = </code><table class="variant"><tr id="type-machine.Supp" class="anchored"><td class="def constructor"><a href="#type-machine.Supp" class="anchor"></a><code>| </code><code><span class="constructor">Supp</span> <span class="keyword">of</span> <a href="../../Config/Arch/index.html#type-t">Config.Arch.t</a></code></td></tr><tr id="type-machine.Other" class="anchored"><td class="def constructor"><a href="#type-machine.Other" class="anchor"></a><code>| </code><code><span class="constructor">Other</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dd><p>The machine type of the ELF file. It can be a known architecture, or one that is not in <a href="../../Arch/index.html"><code>Arch</code></a></p></dd></dl><dl><dt class="spec value" id="val-machine_of_linksem"><a href="#val-machine_of_linksem" class="anchor"></a><code><span class="keyword">val</span> machine_of_linksem : Nat_big_num.num <span>&#45;&gt;</span> <a href="index.html#type-machine">machine</a></code></dt><dd><p>Convert the linksem machine number to <a href="index.html#type-machine"><code>machine</code></a></p></dd></dl><dl><dt class="spec value" id="val-machine_to_string"><a href="#val-machine_to_string" class="anchor"></a><code><span class="keyword">val</span> machine_to_string : <a href="index.html#type-machine">machine</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert a <a href="index.html#type-machine"><code>machine</code></a> to a human readable string</p></dd></dl><dl><dt class="spec value" id="val-pp_machine"><a href="#val-pp_machine" class="anchor"></a><code><span class="keyword">val</span> pp_machine : <a href="index.html#type-machine">machine</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints a <a href="index.html#type-machine"><code>machine</code></a></p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.filename" class="anchored"><td class="def field"><a href="#type-t.filename" class="anchor"></a><code>filename : string;</code></td><td class="doc"><p>The name on the file system. Useful for error messages</p></td></tr><tr id="type-t.symbols" class="anchored"><td class="def field"><a href="#type-t.symbols" class="anchor"></a><code>symbols : <a href="../SymTable/index.html#type-t">SymTbl.t</a>;</code></td><td class="doc"><p>The symbol table</p></td></tr><tr id="type-t.entry" class="anchored"><td class="def field"><a href="#type-t.entry" class="anchor"></a><code>entry : int;</code></td><td class="doc"><p>The address of the entry point; only used in <code>dumpSym.ml</code></p></td></tr><tr id="type-t.machine" class="anchored"><td class="def field"><a href="#type-t.machine" class="anchor"></a><code>machine : <a href="index.html#type-machine">machine</a>;</code></td><td class="doc"><p>The target architecture of the file; only used in <code>arch.ml, dumpSym.ml, dw.ml</code></p></td></tr><tr id="type-t.linksem" class="anchored"><td class="def field"><a href="#type-t.linksem" class="anchor"></a><code>linksem : Elf_file.elf_file;</code></td><td class="doc"><p>The original linksem structure for the file; only used in <code>dw.ml</code></p></td></tr><tr id="type-t.rodata" class="anchored"><td class="def field"><a href="#type-t.rodata" class="anchor"></a><code>rodata : <a href="../Segment/index.html#type-t">Segment.t</a>;</code></td><td class="doc"><p>The read-only data section</p></td></tr></table><code>}</code></dt><dd><p>The type containing all the information about an ELF file</p></dd></dl><dl><dt class="spec exception" id="exception-ElfError"><a href="#exception-ElfError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">ElfError</span> <span class="keyword">of</span> string</code></dt><dd><p>Error on Elf parsing</p></dd></dl><dl><dt class="spec value" id="val-elferror"><a href="#val-elferror" class="anchor"></a><code><span class="keyword">val</span> elferror : <span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Throw an <a href="index.html#exception-ElfError"><code>ElfError</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Parse an ELF file to create an <a href="index.html#type-t"><code>Elf.File.t</code></a> using Linksem.</p><p>May raise an <a href="index.html#exception-ElfError"><code>ElfError</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>File (read-dwarf.Elf.File)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; File</nav><header class="odoc-preamble"><h1>Module <code><span>Elf.File</span></code></h1><p>This module represent an ELF 64 file. We do not deal with 32 bit ELF files for now The main interesting information is the symbol table.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-SymTbl"><a href="#module-SymTbl" class="anchor"></a><code><span><span class="keyword">module</span> SymTbl</span><span> = <a href="../SymTable/index.html">SymTable</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-machine"><a href="#type-machine" class="anchor"></a><code><span><span class="keyword">type</span> machine</span><span> = </span></code><ol><li id="type-machine.Supp" class="def variant constructor anchored"><a href="#type-machine.Supp" class="anchor"></a><code><span>| </span><span><span class="constructor">Supp</span> <span class="keyword">of</span> <a href="../../Config/Arch/index.html#type-t">Config.Arch.t</a></span></code></li><li id="type-machine.Other" class="def variant constructor anchored"><a href="#type-machine.Other" class="anchor"></a><code><span>| </span><span><span class="constructor">Other</span> <span class="keyword">of</span> int</span></code></li></ol></div><div class="spec-doc"><p>The machine type of the ELF file. It can be a known architecture, or one that is not in <a href="../../Arch/index.html"><code>Arch</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-machine_of_linksem"><a href="#val-machine_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> machine_of_linksem : <span><span class="xref-unresolved">Nat_big_num</span>.num <span class="arrow">&#45;&gt;</span></span> <a href="#type-machine">machine</a></span></code></div><div class="spec-doc"><p>Convert the linksem machine number to <a href="#type-t.machine"><code>machine</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-machine_to_string"><a href="#val-machine_to_string" class="anchor"></a><code><span><span class="keyword">val</span> machine_to_string : <span><a href="#type-machine">machine</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert a <a href="#type-t.machine"><code>machine</code></a> to a human readable string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_machine"><a href="#val-pp_machine" class="anchor"></a><code><span><span class="keyword">val</span> pp_machine : <span><a href="#type-machine">machine</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints a <a href="#type-t.machine"><code>machine</code></a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SMap"><a href="#module-SMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SMap/index.html">SMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-section"><a href="#type-section" class="anchor"></a><code><span><span class="keyword">type</span> section</span><span> = </span><span>{</span></code><ol><li id="type-section.name" class="def record field anchored"><a href="#type-section.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-section.size" class="def record field anchored"><a href="#type-section.size" class="anchor"></a><code><span>size : int;</span></code></li><li id="type-section.align" class="def record field anchored"><a href="#type-section.align" class="anchor"></a><code><span>align : int;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.filename" class="def record field anchored"><a href="#type-t.filename" class="anchor"></a><code><span>filename : string;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The name on the file system. Useful for error messages</p><span class="comment-delim">*)</span></div></li><li id="type-t.symbols" class="def record field anchored"><a href="#type-t.symbols" class="anchor"></a><code><span>symbols : <a href="../SymTable/index.html#type-t">SymTbl.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The symbol table</p><span class="comment-delim">*)</span></div></li><li id="type-t.entry" class="def record field anchored"><a href="#type-t.entry" class="anchor"></a><code><span>entry : int;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The address of the entry point; only used in <code>dumpSym.ml</code></p><span class="comment-delim">*)</span></div></li><li id="type-t.machine" class="def record field anchored"><a href="#type-t.machine" class="anchor"></a><code><span>machine : <a href="#type-machine">machine</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The target architecture of the file; only used in <code>arch.ml, dumpSym.ml, dw.ml</code></p><span class="comment-delim">*)</span></div></li><li id="type-t.linksem" class="def record field anchored"><a href="#type-t.linksem" class="anchor"></a><code><span>linksem : <span class="xref-unresolved">Elf_file</span>.elf_file;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The original linksem structure for the file; only used in <code>dw.ml</code></p><span class="comment-delim">*)</span></div></li><li id="type-t.rodata" class="def record field anchored"><a href="#type-t.rodata" class="anchor"></a><code><span>rodata : <span><a href="../Segment/index.html#type-t">Segment.t</a> <a href="SMap/index.html#type-t">SMap.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The read-only data sections</p><span class="comment-delim">*)</span></div></li><li id="type-t.sections" class="def record field anchored"><a href="#type-t.sections" class="anchor"></a><code><span>sections : <span><a href="#type-section">section</a> list</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type containing all the information about an ELF file</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-ElfError"><a href="#exception-ElfError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">ElfError</span> <span class="keyword">of</span> string</span></code></div><div class="spec-doc"><p>Error on Elf parsing</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elferror"><a href="#val-elferror" class="anchor"></a><code><span><span class="keyword">val</span> elferror : <span><span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Throw an <a href="#exception-ElfError"><code>ElfError</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Parse an ELF file to create an <a href="#type-t"><code>Elf.File.t</code></a> using Linksem.</p><p>May raise an <a href="#exception-ElfError"><code>ElfError</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Elf/Segment/index.html b/doc/html/read-dwarf/Elf/Segment/index.html
index 530ee09a..267dcfb7 100644
--- a/doc/html/read-dwarf/Elf/Segment/index.html
+++ b/doc/html/read-dwarf/Elf/Segment/index.html
@@ -1,2 +1,10 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Segment (read-dwarf.Elf.Segment)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; Segment</nav><h1>Module <code>Elf.Segment</code></h1></header><aside><p>The goal of this module is to represent a segment as loaded in memory. In particular, all information about file layout is intentionally lost I use basic ints for speed. It it fails for some reason, I'll move to int64s.</p><p>This is basically a <a href="../../Utils/BytesSeq/index.html"><code>BytesSeq</code></a> with metadata.</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.data" class="anchored"><td class="def field"><a href="#type-t.data" class="anchor"></a><code>data : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a>;</code></td></tr><tr id="type-t.addr" class="anchored"><td class="def field"><a href="#type-t.addr" class="anchor"></a><code>addr : int;</code></td><td class="doc"><p>The actual start address of the BytesSeq</p></td></tr><tr id="type-t.size" class="anchored"><td class="def field"><a href="#type-t.size" class="anchor"></a><code>size : int;</code></td><td class="doc"><p>redundant with <a href="../../Utils/BytesSeq/index.html#val-length"><code>BytesSeq.length</code></a> data</p></td></tr><tr id="type-t.read" class="anchored"><td class="def field"><a href="#type-t.read" class="anchor"></a><code>read : bool;</code></td></tr><tr id="type-t.write" class="anchored"><td class="def field"><a href="#type-t.write" class="anchor"></a><code>write : bool;</code></td></tr><tr id="type-t.execute" class="anchored"><td class="def field"><a href="#type-t.execute" class="anchor"></a><code>execute : bool;</code></td></tr></table><code>}</code></dt><dd><p>The type of a segment</p></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : Elf_interpreted_segment.elf64_interpreted_segment <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Loads a <a href="index.html#type-t"><code>t</code></a> using a linksem interpreted segment.</p></dd></dl><dl><dt class="spec value" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span class="keyword">val</span> is_in : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if an address is inside a segment</p></dd></dl><dl><dt class="spec value" id="val-get_addr"><a href="#val-get_addr" class="anchor"></a><code><span class="keyword">val</span> get_addr : <span>(<a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get a value at an address which is in this segment using the getter provided</p></dd></dl><dl><dt class="spec value" id="val-get_addr_list_opt"><a href="#val-get_addr_list_opt" class="anchor"></a><code><span class="keyword">val</span> get_addr_list_opt : <span>(<a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> list</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Get a value at an address which is one of the segment of this list. It must be entirely in one of the segment</p></dd></dl><dl><dt class="spec value" id="val-get_containing"><a href="#val-get_containing" class="anchor"></a><code><span class="keyword">val</span> get_containing : <span><a href="index.html#type-t">t</a> list</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> option</span></code></dt><dd><p>Get the segment containing an address, among a list of them or <code>None</code></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Segment (read-dwarf.Elf.Segment)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; Segment</nav><header class="odoc-preamble"><h1>Module <code><span>Elf.Segment</span></code></h1><p>The goal of this module is to represent a segment as loaded in memory. In particular, all information about file layout is intentionally lost I use basic ints for speed. It it fails for some reason, I'll move to int64s.</p><p>This is basically a <a href="../../Utils/BytesSeq/index.html"><code>Utils.BytesSeq</code></a> with metadata.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.data" class="def record field anchored"><a href="#type-t.data" class="anchor"></a><code><span>data : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <a href="../Relocations/index.html#type-t">Relocations.t</a>;</span></code></li><li id="type-t.addr" class="def record field anchored"><a href="#type-t.addr" class="anchor"></a><code><span>addr : int;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The actual start address of the BytesSeq</p><span class="comment-delim">*)</span></div></li><li id="type-t.size" class="def record field anchored"><a href="#type-t.size" class="anchor"></a><code><span>size : int;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>redundant with <a href="../../Utils/BytesSeq/index.html#val-length"><code>Utils.BytesSeq.length</code></a> data</p><span class="comment-delim">*)</span></div></li><li id="type-t.read" class="def record field anchored"><a href="#type-t.read" class="anchor"></a><code><span>read : bool;</span></code></li><li id="type-t.write" class="def record field anchored"><a href="#type-t.write" class="anchor"></a><code><span>write : bool;</span></code></li><li id="type-t.execute" class="def record field anchored"><a href="#type-t.execute" class="anchor"></a><code><span>execute : bool;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type of a segment</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><span class="xref-unresolved">Elf_interpreted_segment</span>.elf64_interpreted_segment <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Loads a <a href="#type-t"><code>t</code></a> using a linksem interpreted segment.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span><span class="keyword">val</span> is_in : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if an address is inside a segment</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_addr"><a href="#val-get_addr" class="anchor"></a><code><span><span class="keyword">val</span> get_addr : 
+  <span><span>(<span><span>(<a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <a href="../Relocations/index.html#type-t">Relocations.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get a value at an address which is in this segment using the getter provided</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_addr_list_opt"><a href="#val-get_addr_list_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_addr_list_opt : 
+  <span><span>(<span><span>(<a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <a href="../Relocations/index.html#type-t">Relocations.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-t">t</a> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Get a value at an address which is one of the segment of this list. It must be entirely in one of the segment</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_containing"><a href="#val-get_containing" class="anchor"></a><code><span><span class="keyword">val</span> get_containing : <span><span><a href="#type-t">t</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> option</span></span></code></div><div class="spec-doc"><p>Get the segment containing an address, among a list of them or <code>None</code></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Elf/SymTable/index.html b/doc/html/read-dwarf/Elf/SymTable/index.html
index 93b539a8..24effb01 100644
--- a/doc/html/read-dwarf/Elf/SymTable/index.html
+++ b/doc/html/read-dwarf/Elf/SymTable/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymTable (read-dwarf.Elf.SymTable)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; SymTable</nav><h1>Module <code>Elf.SymTable</code></h1></header><aside><p>The module provide a type to represent a symbol table.</p><p>The interesting operations provided are fetching symbol by name and knowing which symbol owns a specific address</p><p><a href="index.html#val-of_position_string"><code>of_position_string</code></a> provides a convenient way of describing a position in the ELF file from a human text input like the CLI.</p></aside><dl><dt class="spec type" id="type-sym"><a href="#type-sym" class="anchor"></a><code><span class="keyword">type</span> sym</code><code> = <a href="../Symbol/index.html#type-t">Symbol.t</a></code></dt><dt class="spec type" id="type-linksem_sym"><a href="#type-linksem_sym" class="anchor"></a><code><span class="keyword">type</span> linksem_sym</code><code> = <a href="../Symbol/index.html#type-linksem_t">Symbol.linksem_t</a></code></dt><dt class="spec type" id="type-sym_offset"><a href="#type-sym_offset" class="anchor"></a><code><span class="keyword">type</span> sym_offset</code><code> = <a href="index.html#type-sym">sym</a> * int</code></dt><dd><p>The type of a symbol with offset</p></dd></dl><dl><dt class="spec type" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span class="keyword">type</span> linksem_t</code><code> = Elf_file.global_symbol_init_info</code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of a symbol table.</p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>The empty symbol table</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-sym">sym</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Return a new table with the symbol added If there already exists a symbol covering the same area, merge them with <a href="../Symbol/index.html#type-t.other_names"><code>Symbol.t.other_names</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_name"><a href="#val-of_name" class="anchor"></a><code><span class="keyword">val</span> of_name : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-sym">sym</a></code></dt><dd><p>Get a symbol by name. Raise <code>Not_found</code> if no name matches</p></dd></dl><dl><dt class="spec value" id="val-of_name_opt"><a href="#val-of_name_opt" class="anchor"></a><code><span class="keyword">val</span> of_name_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span><a href="index.html#type-sym">sym</a> option</span></code></dt><dd><p>Get a symbol by name, None if no name matches</p></dd></dl><dl><dt class="spec value" id="val-of_addr"><a href="#val-of_addr" class="anchor"></a><code><span class="keyword">val</span> of_addr : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-sym">sym</a></code></dt><dd><p>Get the symbol owning that address. Not_found is raised if no symbol own that address.data See <a href="index.html#val-of_addr_opt"><code>of_addr_opt</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_addr_opt"><a href="#val-of_addr_opt" class="anchor"></a><code><span class="keyword">val</span> of_addr_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-sym">sym</a> option</span></code></dt><dd><p>Get the symbol owning that address. None if no symbol own that address. See <a href="index.html#val-of_addr"><code>of_addr</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_addr_with_offset"><a href="#val-of_addr_with_offset" class="anchor"></a><code><span class="keyword">val</span> of_addr_with_offset : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-sym_offset">sym_offset</a></code></dt><dd><p>Get a symbol with the offset that correspond to that address</p></dd></dl><dl><dt class="spec value" id="val-of_addr_with_offset_opt"><a href="#val-of_addr_with_offset_opt" class="anchor"></a><code><span class="keyword">val</span> of_addr_with_offset_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-sym_offset">sym_offset</a> option</span></code></dt><dd><p>Get a symbol with the offset that correspond to that address</p></dd></dl><dl><dt class="spec value" id="val-to_addr_offset"><a href="#val-to_addr_offset" class="anchor"></a><code><span class="keyword">val</span> to_addr_offset : <a href="index.html#type-sym_offset">sym_offset</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get back the raw address from a symbol+offset value</p></dd></dl><dl><dt class="spec value" id="val-string_of_sym_offset"><a href="#val-string_of_sym_offset" class="anchor"></a><code><span class="keyword">val</span> string_of_sym_offset : <a href="index.html#type-sym_offset">sym_offset</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Transform a symbol + offset into the corresponding string</p></dd></dl><dl><dt class="spec value" id="val-sym_offset_of_string"><a href="#val-sym_offset_of_string" class="anchor"></a><code><span class="keyword">val</span> sym_offset_of_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-sym_offset">sym_offset</a></code></dt><dd><p>Transform a symbol + offset string into the actual symbol and the integer offset</p></dd></dl><dl><dt class="spec value" id="val-of_position_string"><a href="#val-of_position_string" class="anchor"></a><code><span class="keyword">val</span> of_position_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-sym_offset">sym_offset</a></code></dt><dd><p>Convert a position string to a symbol + offset</p><p>A position string is a string describing a position in an ELF file. Two format are accepted for now:</p><ul><li>A raw address of the form &quot;0x40cafe&quot;</li><li>A symbol name with optional offset like &quot;sym&quot; or &quot;sym+4&quot; or &quot;sym+0x4&quot;</li></ul></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : <span><a href="../Segment/index.html#type-t">Segment.t</a> list</span> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Extract the symbol from the linksem symbol representation.</p><p>Need the segments for filling the missing symbol data</p></dd></dl><dl><dt class="spec value" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span class="keyword">val</span> pp_raw : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the table as a raw ocaml value</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>(<a href="index.html#type-sym">sym</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterate through all the symbols in the table.</p></dd></dl><dl><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span>(<a href="index.html#type-sym">sym</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Fold over all the symbols in the table.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymTable (read-dwarf.Elf.SymTable)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; SymTable</nav><header class="odoc-preamble"><h1>Module <code><span>Elf.SymTable</span></code></h1><p>The module provide a type to represent a symbol table.</p><p>The interesting operations provided are fetching symbol by name and knowing which symbol owns a specific address</p><p><a href="#val-of_position_string"><code>of_position_string</code></a> provides a convenient way of describing a position in the ELF file from a human text input like the CLI.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-sym"><a href="#type-sym" class="anchor"></a><code><span><span class="keyword">type</span> sym</span><span> = <a href="../Symbol/index.html#type-t">Symbol.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_sym"><a href="#type-linksem_sym" class="anchor"></a><code><span><span class="keyword">type</span> linksem_sym</span><span> = <a href="../Symbol/index.html#type-linksem_t">Symbol.linksem_t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-sym_offset"><a href="#type-sym_offset" class="anchor"></a><code><span><span class="keyword">type</span> sym_offset</span><span> = <a href="#type-sym">sym</a> * int</span></code></div><div class="spec-doc"><p>The type of a symbol with offset</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span><span class="keyword">type</span> linksem_t</span><span> = <a href="../LinksemRelocatable/index.html#type-global_symbol_init_info">LinksemRelocatable.global_symbol_init_info</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of a symbol table.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The empty symbol table</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-sym">sym</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Return a new table with the symbol added If there already exists a symbol covering the same area, merge them with <a href="../Symbol/index.html#type-t.other_names"><code>Symbol.t.other_names</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_name"><a href="#val-of_name" class="anchor"></a><code><span><span class="keyword">val</span> of_name : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-sym">sym</a></span></code></div><div class="spec-doc"><p>Get a symbol by name. Raise <code>Not_found</code> if no name matches</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_name_opt"><a href="#val-of_name_opt" class="anchor"></a><code><span><span class="keyword">val</span> of_name_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-sym">sym</a> option</span></span></code></div><div class="spec-doc"><p>Get a symbol by name, None if no name matches</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_addr"><a href="#val-of_addr" class="anchor"></a><code><span><span class="keyword">val</span> of_addr : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Address/index.html#type-t">Address.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-sym">sym</a></span></code></div><div class="spec-doc"><p>Get the symbol owning that address. Not_found is raised if no symbol own that address.data See <a href="#val-of_addr_opt"><code>of_addr_opt</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_addr_opt"><a href="#val-of_addr_opt" class="anchor"></a><code><span><span class="keyword">val</span> of_addr_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Address/index.html#type-t">Address.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-sym">sym</a> option</span></span></code></div><div class="spec-doc"><p>Get the symbol owning that address. None if no symbol own that address. See <a href="#val-of_addr"><code>of_addr</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_addr_with_offset"><a href="#val-of_addr_with_offset" class="anchor"></a><code><span><span class="keyword">val</span> of_addr_with_offset : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Address/index.html#type-t">Address.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-sym_offset">sym_offset</a></span></code></div><div class="spec-doc"><p>Get a symbol with the offset that correspond to that address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_addr_with_offset_opt"><a href="#val-of_addr_with_offset_opt" class="anchor"></a><code><span><span class="keyword">val</span> of_addr_with_offset_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Address/index.html#type-t">Address.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-sym_offset">sym_offset</a> option</span></span></code></div><div class="spec-doc"><p>Get a symbol with the offset that correspond to that address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_addr_offset"><a href="#val-to_addr_offset" class="anchor"></a><code><span><span class="keyword">val</span> to_addr_offset : <span><a href="#type-sym_offset">sym_offset</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Address/index.html#type-t">Address.t</a></span></code></div><div class="spec-doc"><p>Get back the raw address from a symbol+offset value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_of_sym_offset"><a href="#val-string_of_sym_offset" class="anchor"></a><code><span><span class="keyword">val</span> string_of_sym_offset : <span><a href="#type-sym_offset">sym_offset</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Transform a symbol + offset into the corresponding string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym_offset_of_string"><a href="#val-sym_offset_of_string" class="anchor"></a><code><span><span class="keyword">val</span> sym_offset_of_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-sym_offset">sym_offset</a></span></code></div><div class="spec-doc"><p>Transform a symbol + offset string into the actual symbol and the integer offset</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_position_string"><a href="#val-of_position_string" class="anchor"></a><code><span><span class="keyword">val</span> of_position_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-sym_offset">sym_offset</a></span></code></div><div class="spec-doc"><p>Convert a position string to a symbol + offset</p><p>A position string is a string describing a position in an ELF file. Two format are accepted for now:</p><ul><li>A raw address of the form &quot;0x40cafe&quot;</li><li>A symbol name with optional offset like &quot;sym&quot; or &quot;sym+4&quot; or &quot;sym+0x4&quot;</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Extract the symbol from the linksem symbol representation.</p><p>Need the segments for filling the missing symbol data</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the table as a raw ocaml value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><a href="#type-sym">sym</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterate through all the symbols in the table.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><a href="#type-sym">sym</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Fold over all the symbols in the table.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Elf/Symbol/index.html b/doc/html/read-dwarf/Elf/Symbol/index.html
index 4af067dd..5dd618d6 100644
--- a/doc/html/read-dwarf/Elf/Symbol/index.html
+++ b/doc/html/read-dwarf/Elf/Symbol/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Symbol (read-dwarf.Elf.Symbol)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; Symbol</nav><h1>Module <code>Elf.Symbol</code></h1></header><aside><p>This module represent an Elf symbol. One important difference with linksem symbols is that the symbols of this module always have the corresponding data (code or initial value). That's why function like <code>of_linksem_with_data</code> exist.</p><p>For now addresses are in ints and assume the top bit is sign extended. It may become Int64.t if required</p></aside><dl><dt class="spec type" id="type-typ"><a href="#type-typ" class="anchor"></a><code><span class="keyword">type</span> typ</code><code> = </code><table class="variant"><tr id="type-typ.NOTYPE" class="anchored"><td class="def constructor"><a href="#type-typ.NOTYPE" class="anchor"></a><code>| </code><code><span class="constructor">NOTYPE</span></code></td></tr><tr id="type-typ.OBJECT" class="anchored"><td class="def constructor"><a href="#type-typ.OBJECT" class="anchor"></a><code>| </code><code><span class="constructor">OBJECT</span></code></td></tr><tr id="type-typ.FUNC" class="anchored"><td class="def constructor"><a href="#type-typ.FUNC" class="anchor"></a><code>| </code><code><span class="constructor">FUNC</span></code></td></tr><tr id="type-typ.SECTION" class="anchored"><td class="def constructor"><a href="#type-typ.SECTION" class="anchor"></a><code>| </code><code><span class="constructor">SECTION</span></code></td></tr><tr id="type-typ.FILE" class="anchored"><td class="def constructor"><a href="#type-typ.FILE" class="anchor"></a><code>| </code><code><span class="constructor">FILE</span></code></td></tr><tr id="type-typ.UNKNOWN" class="anchored"><td class="def constructor"><a href="#type-typ.UNKNOWN" class="anchor"></a><code>| </code><code><span class="constructor">UNKNOWN</span></code></td></tr></table></dt><dd><p>The type of the ELF symbol</p></dd></dl><dl><dt class="spec type" id="type-linksem_typ"><a href="#type-linksem_typ" class="anchor"></a><code><span class="keyword">type</span> linksem_typ</code><code> = Z.t</code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.name" class="anchored"><td class="def field"><a href="#type-t.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-t.other_names" class="anchored"><td class="def field"><a href="#type-t.other_names" class="anchor"></a><code>other_names : <span>string list</span>;</code></td></tr><tr id="type-t.typ" class="anchored"><td class="def field"><a href="#type-t.typ" class="anchor"></a><code>typ : <a href="index.html#type-typ">typ</a>;</code></td></tr><tr id="type-t.addr" class="anchored"><td class="def field"><a href="#type-t.addr" class="anchor"></a><code>addr : int;</code></td></tr><tr id="type-t.size" class="anchored"><td class="def field"><a href="#type-t.size" class="anchor"></a><code>size : int;</code></td></tr><tr id="type-t.writable" class="anchored"><td class="def field"><a href="#type-t.writable" class="anchor"></a><code>writable : bool;</code></td></tr><tr id="type-t.data" class="anchored"><td class="def field"><a href="#type-t.data" class="anchor"></a><code>data : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a>;</code></td></tr></table><code>}</code></dt><dd><p>The ELF symbol. This type guarantee the data exists contrary to linksem symbols (it may be all zeros though)</p></dd></dl><dl><dt class="spec type" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span class="keyword">type</span> linksem_t</code><code> = string * <span>(Z.t * Z.t * Z.t * <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span> * Z.t)</span></code></dt><dd><p>The type of an ELF symbol in linksem. See <a href="index.html#val-of_linksem"><code>of_linksem</code></a></p></dd></dl><dl><dt class="spec value" id="val-push_name"><a href="#val-push_name" class="anchor"></a><code><span class="keyword">val</span> push_name : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add a name to the other names list</p></dd></dl><dl><dt class="spec value" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span class="keyword">val</span> is_in : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if an address is in a symbol</p></dd></dl><dl><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>For conformance with the <a href="../../Utils/RngMap/module-type-LenObject/index.html"><code>Utils.RngMap.LenObject</code></a> module type</p></dd></dl><dl><dt class="spec value" id="val-typ_of_linksem"><a href="#val-typ_of_linksem" class="anchor"></a><code><span class="keyword">val</span> typ_of_linksem : <a href="index.html#type-linksem_typ">linksem_typ</a> <span>&#45;&gt;</span> <a href="index.html#type-typ">typ</a></code></dt><dd><p>Convert the integer type into typ</p></dd></dl><dl><dt class="spec value" id="val-linksem_typ"><a href="#val-linksem_typ" class="anchor"></a><code><span class="keyword">val</span> linksem_typ : <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-linksem_typ">linksem_typ</a></code></dt><dd><p>Get the type from the linksem symbol type</p></dd></dl><dl><dt class="spec exception" id="exception-LoadingError"><a href="#exception-LoadingError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">LoadingError</span> <span class="keyword">of</span> string * int</code></dt><dd><p><code>LoadingError(name,addr)</code> means that symbol <code>name</code> at <code>addr</code> could not be loaded.</p></dd></dl><dl><dt class="spec value" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span class="keyword">val</span> of_linksem : <span><a href="../Segment/index.html#type-t">Segment.t</a> list</span> <span>&#45;&gt;</span> <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert a symbol from linksem to read-dwarf representation using the segment data</p><p>May raise <a href="index.html#exception-LoadingError"><code>LoadingError</code></a> when the symbol has no data and the data cannot be found in the segments</p></dd></dl><dl><dt class="spec value" id="val-is_interesting"><a href="#val-is_interesting" class="anchor"></a><code><span class="keyword">val</span> is_interesting : <a href="index.html#type-typ">typ</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if a symbol type is interesting for readDwarf purposes</p></dd></dl><dl><dt class="spec value" id="val-is_interesting_linksem"><a href="#val-is_interesting_linksem" class="anchor"></a><code><span class="keyword">val</span> is_interesting_linksem : <a href="index.html#type-linksem_t">linksem_t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if a linksem symbol is interesting for readDwarf purposes</p></dd></dl><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></code></dt><dd><p>Take the BytesSeq.t corresponding to the offset and length</p></dd></dl><dl><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Starting address comparison</p></dd></dl><dl><dt class="spec value" id="val-pp_typ"><a href="#val-pp_typ" class="anchor"></a><code><span class="keyword">val</span> pp_typ : <a href="index.html#type-typ">typ</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints a symbol type</p></dd></dl><dl><dt class="spec value" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span class="keyword">val</span> pp_raw : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Raw pretty printing of a symbol</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Symbol (read-dwarf.Elf.Symbol)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Elf</a> &#x00BB; Symbol</nav><header class="odoc-preamble"><h1>Module <code><span>Elf.Symbol</span></code></h1><p>This module represent an Elf symbol. One important difference with linksem symbols is that the symbols of this module always have the corresponding data (code or initial value). That's why function like <code>of_linksem_with_data</code> exist.</p><p>For now addresses are in ints and assume the top bit is sign extended. It may become Int64.t if required</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-typ"><a href="#type-typ" class="anchor"></a><code><span><span class="keyword">type</span> typ</span><span> = </span></code><ol><li id="type-typ.NOTYPE" class="def variant constructor anchored"><a href="#type-typ.NOTYPE" class="anchor"></a><code><span>| </span><span><span class="constructor">NOTYPE</span></span></code></li><li id="type-typ.OBJECT" class="def variant constructor anchored"><a href="#type-typ.OBJECT" class="anchor"></a><code><span>| </span><span><span class="constructor">OBJECT</span></span></code></li><li id="type-typ.FUNC" class="def variant constructor anchored"><a href="#type-typ.FUNC" class="anchor"></a><code><span>| </span><span><span class="constructor">FUNC</span></span></code></li><li id="type-typ.SECTION" class="def variant constructor anchored"><a href="#type-typ.SECTION" class="anchor"></a><code><span>| </span><span><span class="constructor">SECTION</span></span></code></li><li id="type-typ.FILE" class="def variant constructor anchored"><a href="#type-typ.FILE" class="anchor"></a><code><span>| </span><span><span class="constructor">FILE</span></span></code></li><li id="type-typ.UNKNOWN" class="def variant constructor anchored"><a href="#type-typ.UNKNOWN" class="anchor"></a><code><span>| </span><span><span class="constructor">UNKNOWN</span></span></code></li></ol></div><div class="spec-doc"><p>The type of the ELF symbol</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_typ"><a href="#type-linksem_typ" class="anchor"></a><code><span><span class="keyword">type</span> linksem_typ</span><span> = <span class="xref-unresolved">Z</span>.t</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-data"><a href="#type-data" class="anchor"></a><code><span><span class="keyword">type</span> data</span><span> = </span><span>{</span></code><ol><li id="type-data.data" class="def record field anchored"><a href="#type-data.data" class="anchor"></a><code><span>data : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a>;</span></code></li><li id="type-data.relocations" class="def record field anchored"><a href="#type-data.relocations" class="anchor"></a><code><span>relocations : <a href="../Relocations/index.html#type-t">Relocations.t</a>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.name" class="def record field anchored"><a href="#type-t.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-t.other_names" class="def record field anchored"><a href="#type-t.other_names" class="anchor"></a><code><span>other_names : <span>string list</span>;</span></code></li><li id="type-t.typ" class="def record field anchored"><a href="#type-t.typ" class="anchor"></a><code><span>typ : <a href="#type-typ">typ</a>;</span></code></li><li id="type-t.addr" class="def record field anchored"><a href="#type-t.addr" class="anchor"></a><code><span>addr : <a href="../Address/index.html#type-t">Address.t</a>;</span></code></li><li id="type-t.size" class="def record field anchored"><a href="#type-t.size" class="anchor"></a><code><span>size : int;</span></code></li><li id="type-t.writable" class="def record field anchored"><a href="#type-t.writable" class="anchor"></a><code><span>writable : bool;</span></code></li><li id="type-t.data" class="def record field anchored"><a href="#type-t.data" class="anchor"></a><code><span>data : <a href="#type-data">data</a>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The ELF symbol. This type guarantee the data exists contrary to linksem symbols (it may be all zeros though)</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-linksem_t"><a href="#type-linksem_t" class="anchor"></a><code><span><span class="keyword">type</span> linksem_t</span><span> = <a href="../LinksemRelocatable/index.html#type-symbol">LinksemRelocatable.symbol</a></span></code></div><div class="spec-doc"><p>The type of an ELF symbol in linksem. See <a href="#val-of_linksem"><code>of_linksem</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-push_name"><a href="#val-push_name" class="anchor"></a><code><span><span class="keyword">val</span> push_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add a name to the other names list</p></div></div><p>Check if an address is in a symbol</p><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>For conformance with the <a href="../../Utils/RngMap/module-type-LenObject/index.html"><code>Utils.RngMap.LenObject</code></a> module type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-typ_of_linksem"><a href="#val-typ_of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> typ_of_linksem : <span><a href="#type-linksem_typ">linksem_typ</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-typ">typ</a></span></code></div><div class="spec-doc"><p>Convert the integer type into typ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-linksem_typ"><a href="#val-linksem_typ" class="anchor"></a><code><span><span class="keyword">val</span> linksem_typ : <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-linksem_typ">linksem_typ</a></span></code></div><div class="spec-doc"><p>Get the type from the linksem symbol type</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-LoadingError"><a href="#exception-LoadingError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">LoadingError</span> <span class="keyword">of</span> string * int</span></code></div><div class="spec-doc"><p><code>LoadingError(name,addr)</code> means that symbol <code>name</code> at <code>addr</code> could not be loaded.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_linksem"><a href="#val-of_linksem" class="anchor"></a><code><span><span class="keyword">val</span> of_linksem : <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert a symbol from linksem to read-dwarf representation using the segment data</p><p>May raise <a href="#exception-LoadingError"><code>LoadingError</code></a> when the symbol has no data and the data cannot be found in the segments</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_interesting"><a href="#val-is_interesting" class="anchor"></a><code><span><span class="keyword">val</span> is_interesting : <span><a href="#type-typ">typ</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if a symbol type is interesting for readDwarf purposes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_interesting_linksem"><a href="#val-is_interesting_linksem" class="anchor"></a><code><span><span class="keyword">val</span> is_interesting_linksem : <span><a href="#type-linksem_t">linksem_t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if a linksem symbol is interesting for readDwarf purposes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-data">data</a></span></code></div><div class="spec-doc"><p>Take the BytesSeq.t corresponding to the offset and length</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Starting address comparison</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_typ"><a href="#val-pp_typ" class="anchor"></a><code><span><span class="keyword">val</span> pp_typ : <span><a href="#type-typ">typ</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints a symbol type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Raw pretty printing of a symbol</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Elf/index.html b/doc/html/read-dwarf/Elf/index.html
index bb94bf45..656e75b8 100644
--- a/doc/html/read-dwarf/Elf/index.html
+++ b/doc/html/read-dwarf/Elf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Elf (read-dwarf.Elf)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Elf</nav><h1>Module <code>Elf</code></h1></header><dl><dt class="spec module" id="module-File"><a href="#module-File" class="anchor"></a><code><span class="keyword">module</span> <a href="File/index.html">File</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Segment"><a href="#module-Segment" class="anchor"></a><code><span class="keyword">module</span> <a href="Segment/index.html">Segment</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-SymTable"><a href="#module-SymTable" class="anchor"></a><code><span class="keyword">module</span> <a href="SymTable/index.html">SymTable</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Symbol"><a href="#module-Symbol" class="anchor"></a><code><span class="keyword">module</span> <a href="Symbol/index.html">Symbol</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Elf (read-dwarf.Elf)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Elf</nav><header class="odoc-preamble"><h1>Module <code><span>Elf</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Address"><a href="#module-Address" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Address/index.html">Address</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-File"><a href="#module-File" class="anchor"></a><code><span><span class="keyword">module</span> <a href="File/index.html">File</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module represent an ELF 64 file. We do not deal with 32 bit ELF files for now The main interesting information is the symbol table.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-LinksemRelocatable"><a href="#module-LinksemRelocatable" class="anchor"></a><code><span><span class="keyword">module</span> <a href="LinksemRelocatable/index.html">LinksemRelocatable</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Relocations"><a href="#module-Relocations" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Relocations/index.html">Relocations</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Segment"><a href="#module-Segment" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Segment/index.html">Segment</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The goal of this module is to represent a segment as loaded in memory. In particular, all information about file layout is intentionally lost I use basic ints for speed. It it fails for some reason, I'll move to int64s.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SymTable"><a href="#module-SymTable" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SymTable/index.html">SymTable</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The module provide a type to represent a symbol table.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Symbol"><a href="#module-Symbol" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Symbol/index.html">Symbol</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module represent an Elf symbol. One important difference with linksem symbols is that the symbols of this module always have the corresponding data (code or initial value). That's why function like <code>of_linksem_with_data</code> exist.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/ConcreteEval/index.html b/doc/html/read-dwarf/Exp/ConcreteEval/index.html
index 83761a80..4f4b7d3a 100644
--- a/doc/html/read-dwarf/Exp/ConcreteEval/index.html
+++ b/doc/html/read-dwarf/Exp/ConcreteEval/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ConcreteEval (read-dwarf.Exp.ConcreteEval)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; ConcreteEval</nav><h1>Module <code>Exp.ConcreteEval</code></h1><p>This module provides a way of making concrete evaluation of an expression. The only required thing is a <a href="index.html#type-context"><code>context</code></a>.</p></header><dl><dt class="spec exception" id="exception-Symbolic"><a href="#exception-Symbolic" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Symbolic</span></code></dt><dd><p>Thrown when trying to concretely evaluate a symbolic expression</p></dd></dl><dl><dt class="spec type" id="type-context"><a href="#type-context" class="anchor"></a><code><span class="keyword">type</span> <span>'v context</span></code><code> = <span class="type-var">'v</span> <span>&#45;&gt;</span> <a href="../Value/index.html#type-t">Value.t</a></code></dt><dd><p>A map from variables to concrete values. This map should throw <a href="index.html#exception-Symbolic"><code>Symbolic</code></a> when the variable should be treated as symbolic.</p></dd></dl><dl><dt class="spec value" id="val-eval"><a href="#val-eval" class="anchor"></a><code><span class="keyword">val</span> eval : <span>?&#8288;ctxt:<span><span class="type-var">'v</span> <a href="index.html#type-context">context</a></span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="../Value/index.html#type-t">Value.t</a></code></dt><dd><p>Evaluate concretely an expression and return a <a href="../Value/index.html"><code>Value</code></a>.</p><p>If the expression is not concrete, it will throw <a href="index.html#exception-Symbolic"><code>Symbolic</code></a>.</p><p>The default <code>ctxt</code> consider all variables to be symbolic.</p><p><code>eval</code> may succeed even if <a href="index.html#val-is_concrete"><code>is_concrete</code></a> is <code>false</code> in presence of conditionals. Indeed only the taken branch of the conditional is evaluated, so the other may be symbolic. For example:</p><pre><code class="ml">eval ExpTyped.(ite ~cond:(bool true) (bits_smt #x2a) (var ...)) = ExpTyped.(bits_smt #x2a)</code></pre></dd></dl><dl><dt class="spec value" id="val-is_concrete"><a href="#val-is_concrete" class="anchor"></a><code><span class="keyword">val</span> is_concrete : <span><span>(<span class="type-var">_</span>, <span class="type-var">_</span>, <span class="type-var">_</span>, <span class="type-var">_</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if an expression is concrete, which means no variables of any kind</p></dd></dl><dl><dt class="spec value" id="val-eval_if_concrete"><a href="#val-eval_if_concrete" class="anchor"></a><code><span class="keyword">val</span> eval_if_concrete : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <span><a href="../Value/index.html#type-t">Value.t</a> option</span></code></dt><dd><p>Evaluate an expression if it's concrete and returns <code>None</code> otherwise</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ConcreteEval (read-dwarf.Exp.ConcreteEval)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; ConcreteEval</nav><header class="odoc-preamble"><h1>Module <code><span>Exp.ConcreteEval</span></code></h1><p>This module provides a way of making concrete evaluation of an expression. The only required thing is a <a href="#type-context"><code>context</code></a>.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec exception anchored" id="exception-Symbolic"><a href="#exception-Symbolic" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Symbolic</span></span></code></div><div class="spec-doc"><p>Thrown when trying to concretely evaluate a symbolic expression</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-context"><a href="#type-context" class="anchor"></a><code><span><span class="keyword">type</span> <span>'v context</span></span><span> = <span><span class="type-var">'v</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Value/index.html#type-t">Value.t</a></span></code></div><div class="spec-doc"><p>A map from variables to concrete values. This map should throw <a href="#exception-Symbolic"><code>Symbolic</code></a> when the variable should be treated as symbolic.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eval"><a href="#val-eval" class="anchor"></a><code><span><span class="keyword">val</span> eval : <span><span class="optlabel">?ctxt</span>:<span><span class="type-var">'v</span> <a href="#type-context">context</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Value/index.html#type-t">Value.t</a></span></code></div><div class="spec-doc"><p>Evaluate concretely an expression and return a <a href="../Value/index.html"><code>Value</code></a>.</p><p>If the expression is not concrete, it will throw <a href="#exception-Symbolic"><code>Symbolic</code></a>.</p><p>The default <code>ctxt</code> consider all variables to be symbolic.</p><p><code>eval</code> may succeed even if <a href="#val-is_concrete"><code>is_concrete</code></a> is <code>false</code> in presence of conditionals. Indeed only the taken branch of the conditional is evaluated, so the other may be symbolic. For example:</p><pre class="language-ocaml"><code> eval ExpTyped.(ite ~cond:(bool true) (bits_smt #x2a) (var ...)) = ExpTyped.(bits_smt #x2a)</code></pre></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_concrete"><a href="#val-is_concrete" class="anchor"></a><code><span><span class="keyword">val</span> is_concrete : <span><span><span>(<span class="type-var">_</span>, <span class="type-var">_</span>, <span class="type-var">_</span>, <span class="type-var">_</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if an expression is concrete, which means no variables of any kind</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eval_if_concrete"><a href="#val-eval_if_concrete" class="anchor"></a><code><span><span class="keyword">val</span> eval_if_concrete : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Value/index.html#type-t">Value.t</a> option</span></span></code></div><div class="spec-doc"><p>Evaluate an expression if it's concrete and returns <code>None</code> otherwise</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/Make/argument-1-Var/index.html b/doc/html/read-dwarf/Exp/Make/argument-1-Var/index.html
index ee51d3fc..ee4a4934 100644
--- a/doc/html/read-dwarf/Exp/Make/argument-1-Var/index.html
+++ b/doc/html/read-dwarf/Exp/Make/argument-1-Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Var (read-dwarf.Exp.Make.1-Var)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Exp</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 1-Var</nav><h1>Parameter <code>Make.1-Var</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of variables</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality predicate that will be passed to expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></dd></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../index.html#type-ty">ty</a></code></dt><dd><p>Get the type of the variable</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Exp.Make.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Exp</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Var</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Equality predicate that will be passed to expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../index.html#type-ty">ty</a></span></code></div><div class="spec-doc"><p>Get the type of the variable</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/Make/index.html b/doc/html/read-dwarf/Exp/Make/index.html
index 51cb1fcf..61f17189 100644
--- a/doc/html/read-dwarf/Exp/Make/index.html
+++ b/doc/html/read-dwarf/Exp/Make/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Exp.Make)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Make</nav><h1>Module <code>Exp.Make</code></h1></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Var/index.html">Var</a> : <a href="../index.html#module-type-Var">Var</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="argument-1-Var/index.html#type-t">Var.t</a></code></dt><dd><p>The type of variable provided in the functor</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></code></dt><dd><p>The type of expression on which this module works</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Test syntactic equality. <code>a + b</code> and <code>b + a</code> would test different under this predicate</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the expression using <a href="../PpExp/index.html"><code>PpExp</code></a></p></dd></dl><dl><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the expression in SMTLIB language</p></dd></dl><dl><dt class="spec value" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span class="keyword">val</span> of_var : <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create an expression from a variable</p></dd></dl><dl><dt class="spec value" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span class="keyword">val</span> add_type : <span><span>(<span class="type-var">'a</span>, <a href="index.html#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert a similar but untyped expression to an expression of type <a href="index.html#type-t"><code>t</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Exp.Make)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Make</nav><header class="odoc-preamble"><h1>Module <code><span>Exp.Make</span></code></h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Var"><a href="#argument-1-Var" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Var/index.html">Var</a></span><span> : <a href="../module-type-Var/index.html">Var</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="argument-1-Var/index.html#type-t">Var.t</a></span></code></div><div class="spec-doc"><p>The type of variable provided in the functor</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span></code></div><div class="spec-doc"><p>The type of expression on which this module works</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test syntactic equality. <code>a + b</code> and <code>b + a</code> would test different under this predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the expression using <a href="../PpExp/index.html"><code>PpExp</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the expression in SMTLIB language</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span><span class="keyword">val</span> of_var : <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create an expression from a variable</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span><span class="keyword">val</span> add_type : <span><span><span>(<span class="type-var">'a</span>, <a href="#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert a similar but untyped expression to an expression of type <a href="#type-t"><code>t</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/PpExp/index.html b/doc/html/read-dwarf/Exp/PpExp/index.html
index d9041a96..4fd1f4e2 100644
--- a/doc/html/read-dwarf/Exp/PpExp/index.html
+++ b/doc/html/read-dwarf/Exp/PpExp/index.html
@@ -1,2 +1,16 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>PpExp (read-dwarf.Exp.PpExp)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; PpExp</nav><h1>Module <code>Exp.PpExp</code></h1><p>This module provides a human readable pretty printing for <a href="../../Ast/index.html"><code>Ast</code></a> expressions</p><p>If you don't want to bother with details, use <code>pp_exp</code> and don't read the rest.</p><p>The precedence are the ones from C/C++ and Ocaml with some tweaks. In particular the precedence between bitwise operation and arithmetic operation are separated, so parenthesis will always be required between them.</p><p>The order is:</p><ul><li>Extraction and extension</li><li>Concatenation</li><li>unary minus, unary bitwise negation, unary reduction</li><li>multiplications, divisions, separately shift</li><li>additions, substractions, separately bitwise operation</li><li>comparisons</li><li>equality</li><li>and</li><li>or</li><li>ifs</li></ul><p>Unary operator cannot linebreak (but their content can)</p><p>Examples:</p><ul><li><code>-a[1-3].2a:6[z+32]</code> which is: <code>(bvneg (concat ((_ extract 3 1) a) ((_ zero_extend 32) #b101010)))</code></li></ul><nav class="toc"><ul><li><a href="#precedence">Precedence</a></li><li><a href="#actual-pretty-printing">Actual Pretty printing</a></li></ul></nav></header><section><header><h2 id="precedence"><a href="#precedence" class="anchor"></a>Precedence</h2></header><dl><dt class="spec type" id="type-prec"><a href="#type-prec" class="anchor"></a><code><span class="keyword">type</span> prec</code><code> = </code><table class="variant"><tr id="type-prec.IF" class="anchored"><td class="def constructor"><a href="#type-prec.IF" class="anchor"></a><code>| </code><code><span class="constructor">IF</span></code></td></tr><tr id="type-prec.OR" class="anchored"><td class="def constructor"><a href="#type-prec.OR" class="anchor"></a><code>| </code><code><span class="constructor">OR</span></code></td></tr><tr id="type-prec.AND" class="anchored"><td class="def constructor"><a href="#type-prec.AND" class="anchor"></a><code>| </code><code><span class="constructor">AND</span></code></td></tr><tr id="type-prec.EQ" class="anchored"><td class="def constructor"><a href="#type-prec.EQ" class="anchor"></a><code>| </code><code><span class="constructor">EQ</span></code></td></tr><tr id="type-prec.COMP" class="anchored"><td class="def constructor"><a href="#type-prec.COMP" class="anchor"></a><code>| </code><code><span class="constructor">COMP</span></code></td></tr><tr id="type-prec.ADD" class="anchored"><td class="def constructor"><a href="#type-prec.ADD" class="anchor"></a><code>| </code><code><span class="constructor">ADD</span></code></td></tr><tr id="type-prec.MUL" class="anchored"><td class="def constructor"><a href="#type-prec.MUL" class="anchor"></a><code>| </code><code><span class="constructor">MUL</span></code></td></tr><tr id="type-prec.BITS" class="anchored"><td class="def constructor"><a href="#type-prec.BITS" class="anchor"></a><code>| </code><code><span class="constructor">BITS</span></code></td></tr><tr id="type-prec.SHIFTS" class="anchored"><td class="def constructor"><a href="#type-prec.SHIFTS" class="anchor"></a><code>| </code><code><span class="constructor">SHIFTS</span></code></td></tr><tr id="type-prec.UNARY" class="anchored"><td class="def constructor"><a href="#type-prec.UNARY" class="anchor"></a><code>| </code><code><span class="constructor">UNARY</span></code></td></tr><tr id="type-prec.CONCAT" class="anchored"><td class="def constructor"><a href="#type-prec.CONCAT" class="anchor"></a><code>| </code><code><span class="constructor">CONCAT</span></code></td></tr><tr id="type-prec.EXTRACT" class="anchored"><td class="def constructor"><a href="#type-prec.EXTRACT" class="anchor"></a><code>| </code><code><span class="constructor">EXTRACT</span></code></td></tr><tr id="type-prec.PARENS" class="anchored"><td class="def constructor"><a href="#type-prec.PARENS" class="anchor"></a><code>| </code><code><span class="constructor">PARENS</span></code></td></tr></table></dt><dd><p>The operators possible precedence</p></dd></dl><dl><dt class="spec value" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span class="keyword">val</span> compat : <span>outer:<a href="index.html#type-prec">prec</a></span> <span>&#45;&gt;</span> <span>inner:<a href="index.html#type-prec">prec</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Figure out if an expression of precedence <code>inner</code> in an expression of precedence <code>outer</code> needs parentheses</p></dd></dl><dl><dt class="spec value" id="val-prec_unop"><a href="#val-prec_unop" class="anchor"></a><code><span class="keyword">val</span> prec_unop : <a href="../../Ast/index.html#type-unop">Ast.unop</a> <span>&#45;&gt;</span> <a href="index.html#type-prec">prec</a></code></dt><dt class="spec value" id="val-prec_bvarith"><a href="#val-prec_bvarith" class="anchor"></a><code><span class="keyword">val</span> prec_bvarith : <a href="../../Ast/index.html#type-bvarith">Ast.bvarith</a> <span>&#45;&gt;</span> <a href="index.html#type-prec">prec</a></code></dt><dt class="spec value" id="val-prec_binop"><a href="#val-prec_binop" class="anchor"></a><code><span class="keyword">val</span> prec_binop : <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span> <span>&#45;&gt;</span> <a href="index.html#type-prec">prec</a></code></dt><dt class="spec value" id="val-prec_bvmanyarith"><a href="#val-prec_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> prec_bvmanyarith : <a href="../../Ast/index.html#type-bvmanyarith">Ast.bvmanyarith</a> <span>&#45;&gt;</span> <a href="index.html#type-prec">prec</a></code></dt><dt class="spec value" id="val-prec_manyop"><a href="#val-prec_manyop" class="anchor"></a><code><span class="keyword">val</span> prec_manyop : <a href="../../Ast/index.html#type-manyop">Ast.manyop</a> <span>&#45;&gt;</span> <a href="index.html#type-prec">prec</a></code></dt></dl></section><section><header><h2 id="actual-pretty-printing"><a href="#actual-pretty-printing" class="anchor"></a>Actual Pretty printing</h2></header><dl><dt class="spec value" id="val-pp_bits"><a href="#val-pp_bits" class="anchor"></a><code><span class="keyword">val</span> pp_bits : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-ppnot"><a href="#val-ppnot" class="anchor"></a><code><span class="keyword">val</span> ppnot : <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span class="keyword">val</span> pp_unop : <a href="../../Ast/index.html#type-unop">Ast.unop</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-sym_bvarith"><a href="#val-sym_bvarith" class="anchor"></a><code><span class="keyword">val</span> sym_bvarith : <a href="../../Ast/index.html#type-bvarith">Ast.bvarith</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-sym_bvcomp"><a href="#val-sym_bvcomp" class="anchor"></a><code><span class="keyword">val</span> sym_bvcomp : <a href="../../Ast/index.html#type-bvcomp">Ast.bvcomp</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span class="keyword">val</span> pp_binop : <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-sym_bvmanyarith"><a href="#val-sym_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> sym_bvmanyarith : <a href="../../Ast/index.html#type-bvmanyarith">Ast.bvmanyarith</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_manyop : <a href="../../Ast/index.html#type-manyop">Ast.manyop</a> <span>&#45;&gt;</span> <span>PPrintEngine.document list</span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_if"><a href="#val-pp_if" class="anchor"></a><code><span class="keyword">val</span> pp_if : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_exp_prec"><a href="#val-pp_exp_prec" class="anchor"></a><code><span class="keyword">val</span> pp_exp_prec : <span>(<span class="type-var">'v</span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document * <a href="index.html#type-prec">prec</a></code></dt><dd><p>Pretty print an expression and return its precedence</p></dd></dl><dl><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>The main function for pretty printing an expression</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>PpExp (read-dwarf.Exp.PpExp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; PpExp</nav><header class="odoc-preamble"><h1>Module <code><span>Exp.PpExp</span></code></h1><p>This module provides a human readable pretty printing for <a href="../../Ast/index.html"><code>Ast</code></a> expressions</p><p>If you don't want to bother with details, use <code>pp_exp</code> and don't read the rest.</p><p>The precedence are the ones from C/C++ and Ocaml with some tweaks. In particular the precedence between bitwise operation and arithmetic operation are separated, so parenthesis will always be required between them.</p><p>The order is:</p><ul><li>Extraction and extension</li><li>Concatenation</li><li>unary minus, unary bitwise negation, unary reduction</li><li>multiplications, divisions, separately shift</li><li>additions, substractions, separately bitwise operation</li><li>comparisons</li><li>equality</li><li>and</li><li>or</li><li>ifs</li></ul><p>Unary operator cannot linebreak (but their content can)</p><p>Examples:</p><ul><li><code>-a[1-3].2a:6[z+32]</code> which is: <code>(bvneg (concat ((_ extract 3 1) a) ((_ zero_extend 32) #b101010)))</code></li></ul></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#precedence">Precedence</a></li><li><a href="#actual-pretty-printing">Actual Pretty printing</a></li></ul></nav></div><div class="odoc-content"><h2 id="precedence"><a href="#precedence" class="anchor"></a>Precedence</h2><div class="odoc-spec"><div class="spec type anchored" id="type-prec"><a href="#type-prec" class="anchor"></a><code><span><span class="keyword">type</span> prec</span><span> = </span></code><ol><li id="type-prec.IF" class="def variant constructor anchored"><a href="#type-prec.IF" class="anchor"></a><code><span>| </span><span><span class="constructor">IF</span></span></code></li><li id="type-prec.OR" class="def variant constructor anchored"><a href="#type-prec.OR" class="anchor"></a><code><span>| </span><span><span class="constructor">OR</span></span></code></li><li id="type-prec.AND" class="def variant constructor anchored"><a href="#type-prec.AND" class="anchor"></a><code><span>| </span><span><span class="constructor">AND</span></span></code></li><li id="type-prec.EQ" class="def variant constructor anchored"><a href="#type-prec.EQ" class="anchor"></a><code><span>| </span><span><span class="constructor">EQ</span></span></code></li><li id="type-prec.COMP" class="def variant constructor anchored"><a href="#type-prec.COMP" class="anchor"></a><code><span>| </span><span><span class="constructor">COMP</span></span></code></li><li id="type-prec.ADD" class="def variant constructor anchored"><a href="#type-prec.ADD" class="anchor"></a><code><span>| </span><span><span class="constructor">ADD</span></span></code></li><li id="type-prec.MUL" class="def variant constructor anchored"><a href="#type-prec.MUL" class="anchor"></a><code><span>| </span><span><span class="constructor">MUL</span></span></code></li><li id="type-prec.BITS" class="def variant constructor anchored"><a href="#type-prec.BITS" class="anchor"></a><code><span>| </span><span><span class="constructor">BITS</span></span></code></li><li id="type-prec.SHIFTS" class="def variant constructor anchored"><a href="#type-prec.SHIFTS" class="anchor"></a><code><span>| </span><span><span class="constructor">SHIFTS</span></span></code></li><li id="type-prec.UNARY" class="def variant constructor anchored"><a href="#type-prec.UNARY" class="anchor"></a><code><span>| </span><span><span class="constructor">UNARY</span></span></code></li><li id="type-prec.CONCAT" class="def variant constructor anchored"><a href="#type-prec.CONCAT" class="anchor"></a><code><span>| </span><span><span class="constructor">CONCAT</span></span></code></li><li id="type-prec.EXTRACT" class="def variant constructor anchored"><a href="#type-prec.EXTRACT" class="anchor"></a><code><span>| </span><span><span class="constructor">EXTRACT</span></span></code></li><li id="type-prec.PARENS" class="def variant constructor anchored"><a href="#type-prec.PARENS" class="anchor"></a><code><span>| </span><span><span class="constructor">PARENS</span></span></code></li></ol></div><div class="spec-doc"><p>The operators possible precedence</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span><span class="keyword">val</span> compat : <span><span class="label">outer</span>:<a href="#type-prec">prec</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">inner</span>:<a href="#type-prec">prec</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Figure out if an expression of precedence <code>inner</code> in an expression of precedence <code>outer</code> needs parentheses</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prec_unop"><a href="#val-prec_unop" class="anchor"></a><code><span><span class="keyword">val</span> prec_unop : <span><a href="../../Ast/index.html#type-unop">Ast.unop</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-prec">prec</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prec_bvarith"><a href="#val-prec_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> prec_bvarith : <span><a href="../../Ast/index.html#type-bvarith">Ast.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-prec">prec</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prec_binop"><a href="#val-prec_binop" class="anchor"></a><code><span><span class="keyword">val</span> prec_binop : <span><span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-prec">prec</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prec_bvmanyarith"><a href="#val-prec_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> prec_bvmanyarith : <span><a href="../../Ast/index.html#type-bvmanyarith">Ast.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-prec">prec</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prec_manyop"><a href="#val-prec_manyop" class="anchor"></a><code><span><span class="keyword">val</span> prec_manyop : <span><a href="../../Ast/index.html#type-manyop">Ast.manyop</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-prec">prec</a></span></code></div></div><h2 id="actual-pretty-printing"><a href="#actual-pretty-printing" class="anchor"></a>Actual Pretty printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bits"><a href="#val-pp_bits" class="anchor"></a><code><span><span class="keyword">val</span> pp_bits : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppnot"><a href="#val-ppnot" class="anchor"></a><code><span><span class="keyword">val</span> ppnot : <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_unop : <span><a href="../../Ast/index.html#type-unop">Ast.unop</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym_bvarith"><a href="#val-sym_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> sym_bvarith : <span><a href="../../Ast/index.html#type-bvarith">Ast.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym_bvcomp"><a href="#val-sym_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> sym_bvcomp : <span><a href="../../Ast/index.html#type-bvcomp">Ast.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_binop : 
+  <span><span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym_bvmanyarith"><a href="#val-sym_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> sym_bvmanyarith : <span><a href="../../Ast/index.html#type-bvmanyarith">Ast.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_manyop : <span><a href="../../Ast/index.html#type-manyop">Ast.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_if"><a href="#val-pp_if" class="anchor"></a><code><span><span class="keyword">val</span> pp_if : 
+  <span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp_prec"><a href="#val-pp_exp_prec" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp_prec : 
+  <span><span>(<span><span class="type-var">'v</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a> * <a href="#type-prec">prec</a></span></code></div><div class="spec-doc"><p>Pretty print an expression and return its precedence</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>The main function for pretty printing an expression</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/Sums/index.html b/doc/html/read-dwarf/Exp/Sums/index.html
index 0e459d63..d78d7340 100644
--- a/doc/html/read-dwarf/Exp/Sums/index.html
+++ b/doc/html/read-dwarf/Exp/Sums/index.html
@@ -1,2 +1,12 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sums (read-dwarf.Exp.Sums)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Sums</nav><h1>Module <code>Exp.Sums</code></h1><p>This module provide sum manipulation functionality on top of typed expression <a href="../Typed/index.html#type-t"><code>Typed.t</code></a></p><p>This provide a semantic view of sums as list of terms and conversion</p></header><dl><dt class="spec value" id="val-split"><a href="#val-split" class="anchor"></a><code><span class="keyword">val</span> split : <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> list</span></code></dt><dd><p>Split an expression as a list of terms. This function sees through +,- and extracts.</p><p>Any expression <code>e</code> should have the same semantic meaning as <code>Typed.sum (split e)</code>.</p><p>TODO I need to sort according to an arbitrary order to be able to compare reliably. This will probably be part of a more general simplifier work.</p></dd></dl><dl><dt class="spec value" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span class="keyword">val</span> merge : <span>size:int</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></code></dt><dd><p>Merge a list of terms into a sum expression. This is an upgrade of <a href="../Typed/index.html#val-sum"><code>Typed.sum</code></a> to allow empty lists. In the case of an empty list, a <code>0</code> of size <code>size</code> will be inserted instead.</p></dd></dl><dl><dt class="spec value" id="val-add_term"><a href="#val-add_term" class="anchor"></a><code><span class="keyword">val</span> add_term : <span>term:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></code></dt><dd><p>Add a <code>term</code> to a sum, This is the same, as using <a href="index.html#val-split"><code>split</code></a>, then adding <code>term</code> to the list, then merging with <a href="../Typed/index.html#val-sum"><code>Typed.sum</code></a></p></dd></dl><dl><dt class="spec value" id="val-remove_term"><a href="#val-remove_term" class="anchor"></a><code><span class="keyword">val</span> remove_term : <span>equal:<span>(<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>term:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> option</span></code></dt><dd><p>Remove a <code>term</code> from a sum. Return <code>Some res</code> if successful and <code>None</code> otherwise.</p></dd></dl><dl><dt class="spec value" id="val-smart_substract"><a href="#val-smart_substract" class="anchor"></a><code><span class="keyword">val</span> smart_substract : <span>equal:<span>(<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>term:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></code></dt><dd><p>Same as <a href="index.html#val-remove_term"><code>remove_term</code></a> but if the <code>term</code> is not found, add the opposite (<a href="../../Ast/index.html#type-unop.Bvneg"><code>Ast.unop.Bvneg</code></a>) to the sum</p></dd></dl><dl><dt class="spec value" id="val-split_concrete"><a href="#val-split_concrete" class="anchor"></a><code><span class="keyword">val</span> split_concrete : <span><span>(<span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> option</span> * <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></code></dt><dd><p>Split away the concrete terms of the sum and the symbolic part. The symbolic part can be <code>None</code> if the expression was fully concrete. If the symbolic part is <code>Some e</code>, then <code>not </code><a href="index.html#val-has_concrete_term"><code>has_concrete_term</code></a><code> e</code> will hold.</p></dd></dl><dl><dt class="spec value" id="val-has_concrete_term"><a href="#val-has_concrete_term" class="anchor"></a><code><span class="keyword">val</span> has_concrete_term : <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tells if an expression has a concrete term</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sums (read-dwarf.Exp.Sums)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Sums</nav><header class="odoc-preamble"><h1>Module <code><span>Exp.Sums</span></code></h1><p>This module provide sum manipulation functionality on top of typed expression <a href="../Typed/index.html#type-t"><code>Typed.t</code></a></p><p>This provide a semantic view of sums as list of terms and conversion</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> list</span></span></code></div><div class="spec-doc"><p>Split an expression as a list of terms. This function sees through +,- and extracts.</p><p>Any expression <code>e</code> should have the same semantic meaning as <code>Typed.sum (split e)</code>.</p><p>TODO I need to sort according to an arbitrary order to be able to compare reliably. This will probably be part of a more general simplifier work.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span><span class="keyword">val</span> merge : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span></code></div><div class="spec-doc"><p>Merge a list of terms into a sum expression. This is an upgrade of <a href="../Typed/index.html#val-sum"><code>Typed.sum</code></a> to allow empty lists. In the case of an empty list, a <code>0</code> of size <code>size</code> will be inserted instead.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_term"><a href="#val-add_term" class="anchor"></a><code><span><span class="keyword">val</span> add_term : <span><span class="label">term</span>:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span></code></div><div class="spec-doc"><p>Add a <code>term</code> to a sum, This is the same, as using <a href="#val-split"><code>split</code></a>, then adding <code>term</code> to the list, then merging with <a href="../Typed/index.html#val-sum"><code>Typed.sum</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_term"><a href="#val-remove_term" class="anchor"></a><code><span><span class="keyword">val</span> remove_term : 
+  <span><span class="label">equal</span>:<span>(<span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">term</span>:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> option</span></span></code></div><div class="spec-doc"><p>Remove a <code>term</code> from a sum. Return <code>Some res</code> if successful and <code>None</code> otherwise.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smart_substract"><a href="#val-smart_substract" class="anchor"></a><code><span><span class="keyword">val</span> smart_substract : 
+  <span><span class="label">equal</span>:<span>(<span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">term</span>:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-remove_term"><code>remove_term</code></a> but if the <code>term</code> is not found, add the opposite (<a href="../../Ast/index.html#type-unop.Bvneg"><code>Ast.unop.Bvneg</code></a>) to the sum</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_concrete"><a href="#val-split_concrete" class="anchor"></a><code><span><span class="keyword">val</span> split_concrete : 
+  <span><span><span>(<span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> option</span> * <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></span></code></div><div class="spec-doc"><p>Split away the concrete terms of the sum and the symbolic part. The symbolic part can be <code>None</code> if the expression was fully concrete. If the symbolic part is <code>Some e</code>, then <code>not </code><a href="#val-has_concrete_term"><code>has_concrete_term</code></a><code> e</code> will hold.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-has_concrete_term"><a href="#val-has_concrete_term" class="anchor"></a><code><span><span class="keyword">val</span> has_concrete_term : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tells if an expression has a concrete term</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/Typed/index.html b/doc/html/read-dwarf/Exp/Typed/index.html
index 5d99b36b..c2a91124 100644
--- a/doc/html/read-dwarf/Exp/Typed/index.html
+++ b/doc/html/read-dwarf/Exp/Typed/index.html
@@ -1,2 +1,7 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Typed (read-dwarf.Exp.Typed)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Typed</nav><h1>Module <code>Exp.Typed</code></h1><p>This module provide operation on typed expressions i.e expressions whose annotations are their SMT type (<a href="../../Ast/index.html#type-ty"><code>Ast.ty</code></a>).</p><nav class="toc"><ul><li><a href="#generic-operation-on-types">Generic operation on types</a></li><li><a href="#generic-constructors">Generic constructors</a></li><li><a href="#specific-constructors">Specific constructors</a></li><li><a href="#add-types">Add types</a></li></ul></nav></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>('v, 'm) t</span></code><code> = <span><span>(<span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></code></dt><dd><p>The type for a typed expression.</p><ul><li>The <code>'v</code> type is the type of expression variable.</li><li>The <code>'m</code> type should be either <a href="../../Ast/index.html#type-no"><code>Ast.no</code></a> if memory operation are disabled or <a href="../../Ast/Size/index.html#type-t"><code>Ast.Size.t</code></a> if they are enabled.</li></ul><p>The let bindings are always disabled.</p></dd></dl><section><header><h2 id="generic-operation-on-types"><a href="#generic-operation-on-types" class="anchor"></a>Generic operation on types</h2></header><dl><dt class="spec value" id="val-get_type"><a href="#val-get_type" class="anchor"></a><code><span class="keyword">val</span> get_type : <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></code></dt><dd><p>Get the type of a typed expression. Specialized version of <a href="../../Ast/Manip/index.html#val-annot_exp"><code>Ast.Manip.annot_exp</code></a></p></dd></dl><dl><dt class="spec value" id="val-is_bool"><a href="#val-is_bool" class="anchor"></a><code><span class="keyword">val</span> is_bool : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_bv"><a href="#val-is_bv" class="anchor"></a><code><span class="keyword">val</span> is_bv : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_enum"><a href="#val-is_enum" class="anchor"></a><code><span class="keyword">val</span> is_enum : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-expect_bool"><a href="#val-expect_bool" class="anchor"></a><code><span class="keyword">val</span> expect_bool : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-expect_bv"><a href="#val-expect_bv" class="anchor"></a><code><span class="keyword">val</span> expect_bv : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-expect_enum"><a href="#val-expect_enum" class="anchor"></a><code><span class="keyword">val</span> expect_enum : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> int</code></dt></dl></section><section><header><h2 id="generic-constructors"><a href="#generic-constructors" class="anchor"></a>Generic constructors</h2><p>This constuctors build a new expression as required, and compute the new type. They assume the operation is well typed (They assert it).</p></header><dl><dt class="spec value" id="val-var"><a href="#val-var" class="anchor"></a><code><span class="keyword">val</span> var : <span>typ:<span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></span> <span>&#45;&gt;</span> <span class="type-var">'v</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-bits"><a href="#val-bits" class="anchor"></a><code><span class="keyword">val</span> bits : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span class="keyword">val</span> bool : bool <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-enum"><a href="#val-enum" class="anchor"></a><code><span class="keyword">val</span> enum : <a href="../../Ast/index.html#type-enum">Ast.enum</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-vec_idx_type"><a href="#val-vec_idx_type" class="anchor"></a><code><span class="keyword">val</span> vec_idx_type : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></code></dt><dd><p>This is completely arbitrary, because it is not currently used.</p></dd></dl><dl><dt class="spec value" id="val-vec"><a href="#val-vec" class="anchor"></a><code><span class="keyword">val</span> vec : <span><span><span>(<span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'a</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> list</span> <span>&#45;&gt;</span> <span><span>(<span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'a</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></code></dt><dt class="spec value" id="val-unop"><a href="#val-unop" class="anchor"></a><code><span class="keyword">val</span> unop : <a href="../../Ast/index.html#type-unop">Ast.unop</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-binop"><a href="#val-binop" class="anchor"></a><code><span class="keyword">val</span> binop : <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-manyop"><a href="#val-manyop" class="anchor"></a><code><span class="keyword">val</span> manyop : <a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>In addition to well-typedness requirement, this function will throw <code>Invalid_argument</code> if the list is empty. If the list has a single element, it will just return that element instead of building the symbolic operation.</p></dd></dl><dl><dt class="spec value" id="val-ite"><a href="#val-ite" class="anchor"></a><code><span class="keyword">val</span> ite : <span>cond:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt></dl></section><section><header><h2 id="specific-constructors"><a href="#specific-constructors" class="anchor"></a>Specific constructors</h2></header><dl><dt class="spec value" id="val-bits_int"><a href="#val-bits_int" class="anchor"></a><code><span class="keyword">val</span> bits_int : <span>size:int</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-bits_smt"><a href="#val-bits_smt" class="anchor"></a><code><span class="keyword">val</span> bits_smt : string <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-zero"><a href="#val-zero" class="anchor"></a><code><span class="keyword">val</span> zero : <span>size:int</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-true_"><a href="#val-true_" class="anchor"></a><code><span class="keyword">val</span> true_ : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-false_"><a href="#val-false_" class="anchor"></a><code><span class="keyword">val</span> false_ : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(+)"><a href="#val-(+)" class="anchor"></a><code><span class="keyword">val</span> (+) : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-sum"><a href="#val-sum" class="anchor"></a><code><span class="keyword">val</span> sum : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(-)"><a href="#val-(-)" class="anchor"></a><code><span class="keyword">val</span> (-) : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(*)"><a href="#val-(*)" class="anchor"></a><code><span class="keyword">val</span> (*) : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-prod"><a href="#val-prod" class="anchor"></a><code><span class="keyword">val</span> prod : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-sdiv"><a href="#val-sdiv" class="anchor"></a><code><span class="keyword">val</span> sdiv : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-not"><a href="#val-not" class="anchor"></a><code><span class="keyword">val</span> not : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-extract"><a href="#val-extract" class="anchor"></a><code><span class="keyword">val</span> extract : <span>first:int</span> <span>&#45;&gt;</span> <span>last:int</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span class="keyword">val</span> eq : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(=)"><a href="#val-(=)" class="anchor"></a><code><span class="keyword">val</span> (=) : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span class="keyword">val</span> concat : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-comp"><a href="#val-comp" class="anchor"></a><code><span class="keyword">val</span> comp : <a href="../../Ast/index.html#type-bvcomp">Ast.bvcomp</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt></dl></section><section><header><h2 id="add-types"><a href="#add-types" class="anchor"></a>Add types</h2></header><dl><dt class="spec value" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span class="keyword">val</span> add_type : a v m. <span>ty_of_var:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'v</span> <span>&#45;&gt;</span> <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Replace the annotation of expression by the SMT types. The expression must be already well typed (you can trust the SMT solver on this one)</p><p>It will still <code>assert</code> that an expression is well typed as a side effect.</p></dd></dl><dl><dt class="spec value" id="val-is_well_typed"><a href="#val-is_well_typed" class="anchor"></a><code><span class="keyword">val</span> is_well_typed : <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if an expression is well typed</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Typed (read-dwarf.Exp.Typed)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Typed</nav><header class="odoc-preamble"><h1>Module <code><span>Exp.Typed</span></code></h1><p>This module provide operation on typed expressions i.e expressions whose annotations are their SMT type (<a href="../../Ast/index.html#type-ty"><code>Ast.ty</code></a>).</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#generic-operation-on-types">Generic operation on types</a></li><li><a href="#generic-constructors">Generic constructors</a></li><li><a href="#specific-constructors">Specific constructors</a></li><li><a href="#add-types">Add types</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>('v, 'm) t</span></span><span> = <span><span>(<span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></span></code></div><div class="spec-doc"><p>The type for a typed expression.</p><ul><li>The <code>'v</code> type is the type of expression variable.</li><li>The <code>'m</code> type should be either <a href="../../Ast/index.html#type-no"><code>Ast.no</code></a> if memory operation are disabled or <a href="../../Ast/Base/Size/index.html#type-t"><code>Ast.Size.t</code></a> if they are enabled.</li></ul><p>The let bindings are always disabled.</p></div></div><h2 id="generic-operation-on-types"><a href="#generic-operation-on-types" class="anchor"></a>Generic operation on types</h2><div class="odoc-spec"><div class="spec value anchored" id="val-get_type"><a href="#val-get_type" class="anchor"></a><code><span><span class="keyword">val</span> get_type : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></span></code></div><div class="spec-doc"><p>Get the type of a typed expression. Specialized version of <a href="../../Ast/Manip/index.html#val-annot_exp"><code>Ast.Manip.annot_exp</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_bool"><a href="#val-is_bool" class="anchor"></a><code><span><span class="keyword">val</span> is_bool : <span><span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_bv"><a href="#val-is_bv" class="anchor"></a><code><span><span class="keyword">val</span> is_bv : <span><span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_enum"><a href="#val-is_enum" class="anchor"></a><code><span><span class="keyword">val</span> is_enum : <span><span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bool"><a href="#val-expect_bool" class="anchor"></a><code><span><span class="keyword">val</span> expect_bool : <span><span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bv"><a href="#val-expect_bv" class="anchor"></a><code><span><span class="keyword">val</span> expect_bv : <span><span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_enum"><a href="#val-expect_enum" class="anchor"></a><code><span><span class="keyword">val</span> expect_enum : <span><span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><h2 id="generic-constructors"><a href="#generic-constructors" class="anchor"></a>Generic constructors</h2><p>This constuctors build a new expression as required, and compute the new type. They assume the operation is well typed (They assert it).</p><div class="odoc-spec"><div class="spec value anchored" id="val-var"><a href="#val-var" class="anchor"></a><code><span><span class="keyword">val</span> var : <span><span class="label">typ</span>:<span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'v</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bits"><a href="#val-bits" class="anchor"></a><code><span><span class="keyword">val</span> bits : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span><span class="keyword">val</span> bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enum"><a href="#val-enum" class="anchor"></a><code><span><span class="keyword">val</span> enum : <span><a href="../../Ast/index.html#type-enum">Ast.enum</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vec_idx_type"><a href="#val-vec_idx_type" class="anchor"></a><code><span><span class="keyword">val</span> vec_idx_type : <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></span></code></div><div class="spec-doc"><p>This is completely arbitrary, because it is not currently used.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vec"><a href="#val-vec" class="anchor"></a><code><span><span class="keyword">val</span> vec : 
+  <span><span><span><span>(<span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'a</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'a</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unop"><a href="#val-unop" class="anchor"></a><code><span><span class="keyword">val</span> unop : <span><a href="../../Ast/index.html#type-unop">Ast.unop</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-binop"><a href="#val-binop" class="anchor"></a><code><span><span class="keyword">val</span> binop : <span><span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-manyop"><a href="#val-manyop" class="anchor"></a><code><span><span class="keyword">val</span> manyop : <span><a href="../../AstGen/Ott/index.html#type-manyop">AstGen.Ott.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>In addition to well-typedness requirement, this function will throw <code>Invalid_argument</code> if the list is empty. If the list has a single element, it will just return that element instead of building the symbolic operation.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ite"><a href="#val-ite" class="anchor"></a><code><span><span class="keyword">val</span> ite : <span><span class="label">cond</span>:<span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><h2 id="specific-constructors"><a href="#specific-constructors" class="anchor"></a>Specific constructors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-bits_int"><a href="#val-bits_int" class="anchor"></a><code><span><span class="keyword">val</span> bits_int : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bits_smt"><a href="#val-bits_smt" class="anchor"></a><code><span><span class="keyword">val</span> bits_smt : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-zero"><a href="#val-zero" class="anchor"></a><code><span><span class="keyword">val</span> zero : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-true_"><a href="#val-true_" class="anchor"></a><code><span><span class="keyword">val</span> true_ : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-false_"><a href="#val-false_" class="anchor"></a><code><span><span class="keyword">val</span> false_ : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(+)"><a href="#val-(+)" class="anchor"></a><code><span><span class="keyword">val</span> (+) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sum"><a href="#val-sum" class="anchor"></a><code><span><span class="keyword">val</span> sum : <span><span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(-)"><a href="#val-(-)" class="anchor"></a><code><span><span class="keyword">val</span> (-) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(*)"><a href="#val-(*)" class="anchor"></a><code><span><span class="keyword">val</span> (*) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prod"><a href="#val-prod" class="anchor"></a><code><span><span class="keyword">val</span> prod : <span><span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sdiv"><a href="#val-sdiv" class="anchor"></a><code><span><span class="keyword">val</span> sdiv : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not"><a href="#val-not" class="anchor"></a><code><span><span class="keyword">val</span> not : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span><span class="keyword">val</span> neg : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-extract"><a href="#val-extract" class="anchor"></a><code><span><span class="keyword">val</span> extract : <span><span class="label">first</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">last</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span><span class="keyword">val</span> eq : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=)"><a href="#val-(=)" class="anchor"></a><code><span><span class="keyword">val</span> (=) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-comp"><a href="#val-comp" class="anchor"></a><code><span><span class="keyword">val</span> comp : <span><a href="../../Ast/index.html#type-bvcomp">Ast.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><h2 id="add-types"><a href="#add-types" class="anchor"></a>Add types</h2><div class="odoc-spec"><div class="spec value anchored" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span><span class="keyword">val</span> add_type : 
+  'a 'v 'm. <span><span class="label">ty_of_var</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'v</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Replace the annotation of expression by the SMT types. The expression must be already well typed (you can trust the SMT solver on this one)</p><p>It will still <code>assert</code> that an expression is well typed as a side effect.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_well_typed"><a href="#val-is_well_typed" class="anchor"></a><code><span><span class="keyword">val</span> is_well_typed : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if an expression is well typed</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/Value/index.html b/doc/html/read-dwarf/Exp/Value/index.html
index 89969f26..67c5cacd 100644
--- a/doc/html/read-dwarf/Exp/Value/index.html
+++ b/doc/html/read-dwarf/Exp/Value/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Exp.Value)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Value</nav><h1>Module <code>Exp.Value</code></h1><p>This module provide a type to represent concrete values.</p><p>There is not concrete value for memory yet, but maybe there should be at some point to be able to fully support concrete evaluation without external tool</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.Bool" class="anchored"><td class="def constructor"><a href="#type-t.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool</code></td></tr><tr id="type-t.Enum" class="anchored"><td class="def constructor"><a href="#type-t.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="../../Ast/index.html#type-enum">Ast.enum</a></code></td></tr><tr id="type-t.Bv" class="anchored"><td class="def constructor"><a href="#type-t.Bv" class="anchor"></a><code>| </code><code><span class="constructor">Bv</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></code></td></tr><tr id="type-t.Vec" class="anchored"><td class="def constructor"><a href="#type-t.Vec" class="anchor"></a><code>| </code><code><span class="constructor">Vec</span> <span class="keyword">of</span> <span><a href="index.html#type-t">t</a> list</span></code></td></tr></table></dt><dd><p>The type of concrete values</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>String representation of concrete values</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty printer for concrete values</p></dd></dl><dl><dt class="spec value" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span class="keyword">val</span> bool : bool <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#type-t.Bool"><code>Bool</code></a> constructor</p></dd></dl><dl><dt class="spec value" id="val-enum"><a href="#val-enum" class="anchor"></a><code><span class="keyword">val</span> enum : <a href="../../Ast/index.html#type-enum">Ast.enum</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#type-t.Enum"><code>Enum</code></a> constructor</p></dd></dl><dl><dt class="spec value" id="val-bv"><a href="#val-bv" class="anchor"></a><code><span class="keyword">val</span> bv : <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#type-t.Bv"><code>Bv</code></a> constructor</p></dd></dl><dl><dt class="spec value" id="val-vec"><a href="#val-vec" class="anchor"></a><code><span class="keyword">val</span> vec : <span><a href="index.html#type-t">t</a> list</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#type-t.Vec"><code>Vec</code></a> constructor</p></dd></dl><dl><dt class="spec value" id="val-expect_bool"><a href="#val-expect_bool" class="anchor"></a><code><span class="keyword">val</span> expect_bool : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Extract a boolean or fail</p></dd></dl><dl><dt class="spec value" id="val-expect_enum"><a href="#val-expect_enum" class="anchor"></a><code><span class="keyword">val</span> expect_enum : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Ast/index.html#type-enum">Ast.enum</a></code></dt><dd><p>Extract an enumeration or fail</p></dd></dl><dl><dt class="spec value" id="val-expect_bv"><a href="#val-expect_bv" class="anchor"></a><code><span class="keyword">val</span> expect_bv : <span>?&#8288;size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></code></dt><dd><p>Extract a bit vector or fail. If <code>size</code> is specified, then it fail if the size don't match</p></dd></dl><dl><dt class="spec value" id="val-to_exp"><a href="#val-to_exp" class="anchor"></a><code><span class="keyword">val</span> to_exp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></code></dt><dd><p>Convert to a constant expression</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Exp.Value)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Value</nav><header class="odoc-preamble"><h1>Module <code><span>Exp.Value</span></code></h1><p>This module provide a type to represent concrete values.</p><p>There is not concrete value for memory yet, but maybe there should be at some point to be able to fully support concrete evaluation without external tool</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.Bool" class="def variant constructor anchored"><a href="#type-t.Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Bool</span> <span class="keyword">of</span> bool</span></code></li><li id="type-t.Enum" class="def variant constructor anchored"><a href="#type-t.Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="../../Ast/index.html#type-enum">Ast.enum</a></span></code></li><li id="type-t.Bv" class="def variant constructor anchored"><a href="#type-t.Bv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bv</span> <span class="keyword">of</span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></span></code></li><li id="type-t.Vec" class="def variant constructor anchored"><a href="#type-t.Vec" class="anchor"></a><code><span>| </span><span><span class="constructor">Vec</span> <span class="keyword">of</span> <span><a href="#type-t">t</a> list</span></span></code></li></ol></div><div class="spec-doc"><p>The type of concrete values</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>String representation of concrete values</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty printer for concrete values</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span><span class="keyword">val</span> bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#type-t.Bool"><code>Bool</code></a> constructor</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enum"><a href="#val-enum" class="anchor"></a><code><span><span class="keyword">val</span> enum : <span><a href="../../Ast/index.html#type-enum">Ast.enum</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#type-t.Enum"><code>Enum</code></a> constructor</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bv"><a href="#val-bv" class="anchor"></a><code><span><span class="keyword">val</span> bv : <span><a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#type-t.Bv"><code>Bv</code></a> constructor</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vec"><a href="#val-vec" class="anchor"></a><code><span><span class="keyword">val</span> vec : <span><span><a href="#type-t">t</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#type-t.Vec"><code>Vec</code></a> constructor</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bool"><a href="#val-expect_bool" class="anchor"></a><code><span><span class="keyword">val</span> expect_bool : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Extract a boolean or fail</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_enum"><a href="#val-expect_enum" class="anchor"></a><code><span><span class="keyword">val</span> expect_enum : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ast/index.html#type-enum">Ast.enum</a></span></code></div><div class="spec-doc"><p>Extract an enumeration or fail</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bv"><a href="#val-expect_bv" class="anchor"></a><code><span><span class="keyword">val</span> expect_bv : <span><span class="optlabel">?size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a></span></code></div><div class="spec-doc"><p>Extract a bit vector or fail. If <code>size</code> is specified, then it fail if the size don't match</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_exp"><a href="#val-to_exp" class="anchor"></a><code><span><span class="keyword">val</span> to_exp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span></code></div><div class="spec-doc"><p>Convert to a constant expression</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/index.html b/doc/html/read-dwarf/Exp/index.html
index 869fe7e1..f9cebcc0 100644
--- a/doc/html/read-dwarf/Exp/index.html
+++ b/doc/html/read-dwarf/Exp/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Exp (read-dwarf.Exp)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Exp</nav><h1>Module <code>Exp</code></h1><p>This module intends to provider a convenience expression module by lifting function like equality or pretty printing from variable to expressions.</p><p>It is restricted to typed expression as defined in <a href="Typed/index.html"><code>Typed</code></a></p><p>For now it also do not support memory expression, but it will soon.</p></header><dl><dt class="spec module" id="module-ConcreteEval"><a href="#module-ConcreteEval" class="anchor"></a><code><span class="keyword">module</span> <a href="ConcreteEval/index.html">ConcreteEval</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provides a way of making concrete evaluation of an expression. The only required thing is a <a href="ConcreteEval/index.html#type-context"><code>context</code></a>.</p></dd></dl><dl><dt class="spec module" id="module-PpExp"><a href="#module-PpExp" class="anchor"></a><code><span class="keyword">module</span> <a href="PpExp/index.html">PpExp</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provides a human readable pretty printing for <a href="../Ast/index.html"><code>Ast</code></a> expressions</p></dd></dl><dl><dt class="spec module" id="module-Sums"><a href="#module-Sums" class="anchor"></a><code><span class="keyword">module</span> <a href="Sums/index.html">Sums</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide sum manipulation functionality on top of typed expression <a href="Typed/index.html#type-t"><code>Typed.t</code></a></p></dd></dl><dl><dt class="spec module" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span class="keyword">module</span> <a href="Typed/index.html">Typed</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide operation on typed expressions i.e expressions whose annotations are their SMT type (<a href="../Ast/index.html#type-ty"><code>Ast.ty</code></a>).</p></dd></dl><dl><dt class="spec module" id="module-Value"><a href="#module-Value" class="anchor"></a><code><span class="keyword">module</span> <a href="Value/index.html">Value</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide a type to represent concrete values.</p></dd></dl><dl><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> ty</code><code> = <span><a href="../Ast/index.html#type-no">Ast.no</a> <a href="../Ast/index.html#type-ty">Ast.ty</a></span></code></dt><dd><p>The type of memory-less expressions</p></dd></dl><dl><dt class="spec module-type" id="module-type-Var"><a href="#module-type-Var" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Var/index.html">Var</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This is the type signature for variable required by this module</p></dd></dl><dl><dt class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The signature of the output module of <a href="Make/index.html"><code>Make</code></a></p></dd></dl><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span class="keyword">module</span> <a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-Var/index.html">Var</a> : <a href="index.html#module-type-Var">Var</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-S">S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="Make/index.html#type-var">var</a> = <a href="Make/argument-1-Var/index.html#type-t">Var.t</a></code></div><div class="spec module" id="module-Pp"><a href="#module-Pp" class="anchor"></a><code><span class="keyword">module</span> Pp = <a href="index.html#module-PpExp">PpExp</a></code></div></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Exp (read-dwarf.Exp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Exp</nav><header class="odoc-preamble"><h1>Module <code><span>Exp</span></code></h1><p>This module intends to provider a convenience expression module by lifting function like equality or pretty printing from variable to expressions.</p><p>It is restricted to typed expression as defined in <a href="Typed/index.html"><code>Typed</code></a></p><p>For now it also do not support memory expression, but it will soon.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-ConcreteEval"><a href="#module-ConcreteEval" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ConcreteEval/index.html">ConcreteEval</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides a way of making concrete evaluation of an expression. The only required thing is a <a href="ConcreteEval/index.html#type-context"><code>context</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-PpExp"><a href="#module-PpExp" class="anchor"></a><code><span><span class="keyword">module</span> <a href="PpExp/index.html">PpExp</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides a human readable pretty printing for <a href="../Ast/index.html"><code>Ast</code></a> expressions</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Sums"><a href="#module-Sums" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Sums/index.html">Sums</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide sum manipulation functionality on top of typed expression <a href="Typed/index.html#type-t"><code>Typed.t</code></a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Typed/index.html">Typed</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide operation on typed expressions i.e expressions whose annotations are their SMT type (<a href="../Ast/index.html#type-ty"><code>Ast.ty</code></a>).</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Value"><a href="#module-Value" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Value/index.html">Value</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a type to represent concrete values.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> ty</span><span> = <span><a href="../Ast/index.html#type-no">Ast.no</a> <a href="../Ast/index.html#type-ty">Ast.ty</a></span></span></code></div><div class="spec-doc"><p>The type of memory-less expressions</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-Var"><a href="#module-type-Var" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Var/index.html">Var</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This is the type signature for variable required by this module</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The signature of the output module of <a href="Make/index.html"><code>Make</code></a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Make/index.html">Make</a></span><span> (<a href="Make/argument-1-Var/index.html">Var</a> : <a href="module-type-Var/index.html">Var</a>) : <a href="module-type-S/index.html">S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-var">var</a> = <a href="Make/argument-1-Var/index.html#type-t">Var.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Pp"><a href="#module-Pp" class="anchor"></a><code><span><span class="keyword">module</span> Pp</span><span> = <a href="PpExp/index.html">PpExp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/module-type-S/index.html b/doc/html/read-dwarf/Exp/module-type-S/index.html
index 9cafd742..edb23b6e 100644
--- a/doc/html/read-dwarf/Exp/module-type-S/index.html
+++ b/doc/html/read-dwarf/Exp/module-type-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Exp.S)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; S</nav><h1>Module type <code>Exp.S</code></h1><p>The signature of the output module of <a href="../Make/index.html"><code>Make</code></a></p></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code></dt><dd><p>The type of variable provided in the functor</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></code></dt><dd><p>The type of expression on which this module works</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Test syntactic equality. <code>a + b</code> and <code>b + a</code> would test different under this predicate</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the expression using <a href="../PpExp/index.html"><code>PpExp</code></a></p></dd></dl><dl><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the expression in SMTLIB language</p></dd></dl><dl><dt class="spec value" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span class="keyword">val</span> of_var : <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create an expression from a variable</p></dd></dl><dl><dt class="spec value" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span class="keyword">val</span> add_type : <span><span>(<span class="type-var">'a</span>, <a href="index.html#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert a similar but untyped expression to an expression of type <a href="index.html#type-t"><code>t</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Exp.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Module type <code><span>Exp.S</span></code></h1><p>The signature of the output module of <a href="../Make/index.html"><code>Make</code></a></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span></code></div><div class="spec-doc"><p>The type of variable provided in the functor</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Typed/index.html#type-t">Typed.t</a></span></span></code></div><div class="spec-doc"><p>The type of expression on which this module works</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test syntactic equality. <code>a + b</code> and <code>b + a</code> would test different under this predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the expression using <a href="../PpExp/index.html"><code>PpExp</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the expression in SMTLIB language</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span><span class="keyword">val</span> of_var : <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create an expression from a variable</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span><span class="keyword">val</span> add_type : <span><span><span>(<span class="type-var">'a</span>, <a href="#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert a similar but untyped expression to an expression of type <a href="#type-t"><code>t</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Exp/module-type-Var/index.html b/doc/html/read-dwarf/Exp/module-type-Var/index.html
index 6e220e36..86cac564 100644
--- a/doc/html/read-dwarf/Exp/module-type-Var/index.html
+++ b/doc/html/read-dwarf/Exp/module-type-Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Exp.Var)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Var</nav><h1>Module type <code>Exp.Var</code></h1><p>This is the type signature for variable required by this module</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of variables</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality predicate that will be passed to expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></dd></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#type-ty">ty</a></code></dt><dd><p>Get the type of the variable</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Exp.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Exp</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Module type <code><span>Exp.Var</span></code></h1><p>This is the type signature for variable required by this module</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Equality predicate that will be passed to expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-ty">ty</a></span></code></div><div class="spec-doc"><p>Get the type of the variable</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/InstructionPipeline.html b/doc/html/read-dwarf/InstructionPipeline.html
index 03863c3c..28828e7a 100644
--- a/doc/html/read-dwarf/InstructionPipeline.html
+++ b/doc/html/read-dwarf/InstructionPipeline.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>InstructionPipeline (read-dwarf.InstructionPipeline)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; InstructionPipeline</nav><h1 id="instruction-pipeline"><a href="#instruction-pipeline" class="anchor"></a>Instruction Pipeline</h1><p>This page describe the whole instruction pipeline from how isla is called, to how to run them on <a href="State/index.html"><span>states</span></a>.</p><p>The main idea to represent instruction semantics, is that of trace. A trace is a list of event that affect the current machine state. Those trace may also contain assertions, which means that the trace only decribes the behavior of a state that satisfy those assertions, and do not define any behavior for a state that do not satisfy those assertion. With a set of such traces you can define the behavior of a whole instruction.</p><p>If a state statisfy none of the assertion of any traces of an instruction then running that instruction on that state is undefined behavior. In pratice even if the normal model of sail fully defines an instruction on every state, we will manually make some behavior undefined. In particular all processors exceptions are considered undefined behavior for now.</p><p>In the implementation there is two different fromat for traces: The original isla format from the isla tool and a custom simpler format in the <a href="Trace/index.html"><code>Trace</code></a> module.</p><nav class="toc"><ul><li><a href="#isla">Isla</a><ul><li><a href="#calling-isla">Calling isla</a></li><li><a href="#preprocessing-of-isla-traces">Preprocessing of isla traces</a></li><li><a href="#isla-traces-caching">Isla traces caching</a></li><li><a href="#typing-and-register-learning">Typing and register learning</a></li><li><a href="#running-isla-traces-directly">Running Isla traces directly</a></li></ul></li><li><a href="#trace-and-instr">Trace and Instr</a></li></ul></nav></header><h2 id="isla"><a href="#isla" class="anchor"></a>Isla</h2><p><a href="https://github.com/rems-project/isla">Isla</a> is a tool to symbolically execute a Sail ISA semantic description. Isla will take such semantics and use it to generate symbolic traces for instructions, In this section I describe how I process those traces. The interesting types are defined in <a href="Isla/index.html"><code>Isla</code></a>.</p><h3 id="calling-isla"><a href="#calling-isla" class="anchor"></a>Calling isla</h3><p>First to call isla itself. All of this is done in <a href="Isla/Server/index.html"><code>Isla.Server</code></a>. The Isla tool suite expect <code>*.ir</code> file that is some sort of preprocessed sail source.</p><p>This processing is done by <code>isla-sail</code>, but they can be found in <a href="https://github.com/rems-project/isla-snapshots"><code>isla-snapshots</code></a>. For now we also keep a working snapshot <code>aarch64.ir</code> in the root directory.</p><p>To call isla, <a href="Isla/Server/index.html"><code>Isla.Server</code></a> use the <code>isla-client</code> program. This program will take an hexadecimal opcode and call the <code>isla_client</code> sail function in the <code>*.ir</code> file. This function take the opcode, decode it and run it, all of which is done symbolically by isla. <code>isla-client</code> then send back a symbolic recording of all operations used by the sail code. This code is parsed using the <code>isla-lang</code> library by the <a href="Isla/index.html"><code>Isla</code></a> module that is a wrapper around <code>isla-lang</code> functionality.</p><h3 id="preprocessing-of-isla-traces"><a href="#preprocessing-of-isla-traces" class="anchor"></a>Preprocessing of isla traces</h3><p>As the raw trace contained by isla are big and contain a lot of useless information, I first preprocess them to remove a maximum of useless part in <a href="Isla/Preprocess/index.html"><code>Isla.Preprocess</code></a></p><h3 id="isla-traces-caching"><a href="#isla-traces-caching" class="anchor"></a>Isla traces caching</h3><p>Isla trace are <a href="Utils/Cache/index.html"><span>cached</span></a> by <a href="Isla/Cache/index.html"><code>Isla.Cache</code></a> by opcode. This organisation assumes that there is no configuration to send to isla before symbolically running an instruction and thus each opcode correspond to a single trace representation.</p><h3 id="typing-and-register-learning"><a href="#typing-and-register-learning" class="anchor"></a>Typing and register learning</h3><p>Then <a href="Isla/Type/index.html"><code>Isla.Type</code></a> can be used to type the isla traces and at the same time discover all register used by the trace and thus potentially add them to the <a href="State/Reg/index.html"><code>State.Reg</code></a> module.</p><h3 id="running-isla-traces-directly"><a href="#running-isla-traces-directly" class="anchor"></a>Running Isla traces directly</h3><p>There are two way of used those isla traces, running them directly on states with <a href="Isla/Run/index.html"><code>Isla.Run</code></a> which is kind of deprecated, or going trough the internal <a href="Trace/index.html"><code>Trace</code></a> format.</p><h2 id="trace-and-instr"><a href="#trace-and-instr" class="anchor"></a>Trace and Instr</h2><p>Even after preprocession, Isla traces are still quite complex. They consider meaningful event that in the usual setting are not like reading a register. They also contain a lot a possible event about processor sleeping and concurency that read-dwarf do not support. Therefore a new trace format has been created in <a href="Trace/index.html"><code>Trace</code></a> that only contains the part of behavior that read-dwarf actually use and understand. The trace are also cached in <a href="Trace/Cache/index.html"><code>Trace.Cache</code></a>.</p><p>Full instruction are represented by <span class="xref-unresolved" title="unresolved reference to &quot;Run.Instr.t&quot;"><a href="Run/index.html#module-Instr"><code>Run.Instr</code></a>.t</span> that contain all the traces but also additional metadata that can be useful.</p><p>See <a href="SymbolicExecution.html"><code>SymbolicExecution</code></a> to see how to run those traces.</p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>InstructionPipeline (read-dwarf.InstructionPipeline)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; InstructionPipeline</nav><header class="odoc-preamble"><h1 id="instruction-pipeline"><a href="#instruction-pipeline" class="anchor"></a>Instruction Pipeline</h1><p>This page describe the whole instruction pipeline from how isla is called, to how to run them on <a href="State/index.html" title="State">states</a>.</p><p>The main idea to represent instruction semantics, is that of trace. A trace is a list of event that affect the current machine state. Those trace may also contain assertions, which means that the trace only decribes the behavior of a state that satisfy those assertions, and do not define any behavior for a state that do not satisfy those assertion. With a set of such traces you can define the behavior of a whole instruction.</p><p>If a state statisfy none of the assertion of any traces of an instruction then running that instruction on that state is undefined behavior. In pratice even if the normal model of sail fully defines an instruction on every state, we will manually make some behavior undefined. In particular all processors exceptions are considered undefined behavior for now.</p><p>In the implementation there is two different fromat for traces: The original isla format from the isla tool and a custom simpler format in the <a href="Trace/index.html"><code>Trace</code></a> module.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#isla">Isla</a><ul><li><a href="#calling-isla">Calling isla</a></li><li><a href="#preprocessing-of-isla-traces">Preprocessing of isla traces</a></li><li><a href="#isla-traces-caching">Isla traces caching</a></li><li><a href="#typing-and-register-learning">Typing and register learning</a></li><li><a href="#running-isla-traces-directly">Running Isla traces directly</a></li></ul></li><li><a href="#trace-and-instr">Trace and Instr</a></li></ul></nav></div><div class="odoc-content"><h2 id="isla"><a href="#isla" class="anchor"></a>Isla</h2><p><a href="https://github.com/rems-project/isla">Isla</a> is a tool to symbolically execute a Sail ISA semantic description. Isla will take such semantics and use it to generate symbolic traces for instructions, In this section I describe how I process those traces. The interesting types are defined in <a href="Isla/index.html"><code>Isla</code></a>.</p><h3 id="calling-isla"><a href="#calling-isla" class="anchor"></a>Calling isla</h3><p>First to call isla itself. All of this is done in <a href="Isla/Server/index.html"><code>Isla.Server</code></a>. The Isla tool suite expect <code>*.ir</code> file that is some sort of preprocessed sail source.</p><p>This processing is done by <code>isla-sail</code>, but they can be found in <a href="https://github.com/rems-project/isla-snapshots"><code>isla-snapshots</code></a>. For now we also keep a working snapshot <code>aarch64.ir</code> in the root directory.</p><p>To call isla, <a href="Isla/Server/index.html"><code>Isla.Server</code></a> use the <code>isla-client</code> program. This program will take an hexadecimal opcode and call the <code>isla_client</code> sail function in the <code>*.ir</code> file. This function take the opcode, decode it and run it, all of which is done symbolically by isla. <code>isla-client</code> then send back a symbolic recording of all operations used by the sail code. This code is parsed using the <code>isla-lang</code> library by the <a href="Isla/index.html"><code>Isla</code></a> module that is a wrapper around <code>isla-lang</code> functionality.</p><h3 id="preprocessing-of-isla-traces"><a href="#preprocessing-of-isla-traces" class="anchor"></a>Preprocessing of isla traces</h3><p>As the raw trace contained by isla are big and contain a lot of useless information, I first preprocess them to remove a maximum of useless part in <a href="Isla/Preprocess/index.html"><code>Isla.Preprocess</code></a></p><h3 id="isla-traces-caching"><a href="#isla-traces-caching" class="anchor"></a>Isla traces caching</h3><p>Isla trace are <a href="Utils/Cache/index.html" title="Utils.Cache">cached</a> by <a href="Isla/Cache/index.html"><code>Isla.Cache</code></a> by opcode. This organisation assumes that there is no configuration to send to isla before symbolically running an instruction and thus each opcode correspond to a single trace representation.</p><h3 id="typing-and-register-learning"><a href="#typing-and-register-learning" class="anchor"></a>Typing and register learning</h3><p>Then <a href="Isla/Type/index.html"><code>Isla.Type</code></a> can be used to type the isla traces and at the same time discover all register used by the trace and thus potentially add them to the <a href="State/Reg/index.html"><code>State.Reg</code></a> module.</p><h3 id="running-isla-traces-directly"><a href="#running-isla-traces-directly" class="anchor"></a>Running Isla traces directly</h3><p>There are two way of used those isla traces, running them directly on states with <a href="Isla/Run/index.html"><code>Isla.Run</code></a> which is kind of deprecated, or going trough the internal <a href="Trace/index.html"><code>Trace</code></a> format.</p><h2 id="trace-and-instr"><a href="#trace-and-instr" class="anchor"></a>Trace and Instr</h2><p>Even after preprocession, Isla traces are still quite complex. They consider meaningful event that in the usual setting are not like reading a register. They also contain a lot a possible event about processor sleeping and concurency that read-dwarf do not support. Therefore a new trace format has been created in <a href="Trace/index.html"><code>Trace</code></a> that only contains the part of behavior that read-dwarf actually use and understand. The trace are also cached in <a href="Trace/Cache/index.html"><code>Trace.Cache</code></a>.</p><p>Full instruction are represented by <code>Run.Instr.t</code> that contain all the traces but also additional metadata that can be useful.</p><p>See <a href="SymbolicExecution.html"><code>SymbolicExecution</code></a> to see how to run those traces.</p></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Base/index.html b/doc/html/read-dwarf/Isla/Base/index.html
index 8799b01e..ee10fecd 100644
--- a/doc/html/read-dwarf/Isla/Base/index.html
+++ b/doc/html/read-dwarf/Isla/Base/index.html
@@ -1,2 +1,25 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Isla.Base)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Base</nav><h1>Module <code>Isla.Base</code></h1><p>This module wraps all <code>isla-lang</code> functionality. No other module should directly touch the <code>Isla_lang</code> module.</p><p>The isla trace syntax is compose of <a href="index.html#type-event"><span>events</span></a> that a regrouped into <a href="index.html#type-trc"><span>traces</span></a>. There are a lot of possible events, and some of them are unsupported. in particular all the ones that deal with concurrency.</p><p>All the variable in isla traces are numbered. They are named <code>v28</code> in the syntax and are represented as a plain <code>int</code> in Ocaml. The structure of the traces is a mix of SMT declaration about those variable and actual processor events. SMT declaration use SMT expressions of type <a href="index.html#type-exp"><code>exp</code></a> which entirely distinct from <a href="../../Ast/index.html#type-exp"><code>Ast.exp</code></a> (Use <a href="../Conv/index.html"><code>Isla.Conv</code></a> to convert). On the contrary processor event do not contain direct SMT expressions but Sail values of type <a href="index.html#type-valu"><code>valu</code></a>. A <a href="index.html#type-valu"><code>valu</code></a> can be either a single symbolic variable, a concrete bitvector/boolean/enumeration value or a more complex sail structure with fields that contain other <a href="index.html#type-valu"><code>valu</code></a>s and some other things.</p><p>Event of reading and writing complex register like <code>PSTATE</code> in <code>AArch64</code> will provide the whole structure as a valu to be read or written. However, Those events may contain a accessor list that implies that only specific field of the struct are written or read. This useful, because of the flat representation of registers in <a href="../../State/Reg/index.html"><code>State.Reg</code></a>: each field is considered to be a separate register.</p><p>The isla types are polymorphic over the annotation because that comes from <code>isla-lang</code>, but in practice the only annotation I use the source position of type <a href="index.html#type-lrng"><code>lrng</code></a>, that's why there is a set of aliases starting with <code>r</code>.</p><nav class="toc"><ul><li><a href="#aliases">Aliases</a></li><li><a href="#islatrace-parsing">IslaTrace parsing</a></li><li><a href="#islatrace-pretty-printing">IslaTrace pretty printing</a></li></ul></nav></header><section><header><h2 id="aliases"><a href="#aliases" class="anchor"></a>Aliases</h2></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Isla_lang.AST</code></span></summary><dl><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = int * int</code></dt><dt class="spec type" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span class="keyword">type</span> lrng</code><code> = Isla_lang__Isla_lang_ast.lrng</code><code> = </code><table class="variant"><tr id="type-lrng.UnknownRng" class="anchored"><td class="def constructor"><a href="#type-lrng.UnknownRng" class="anchor"></a><code>| </code><code><span class="constructor">UnknownRng</span></code></td></tr><tr id="type-lrng.Generated" class="anchored"><td class="def constructor"><a href="#type-lrng.Generated" class="anchor"></a><code>| </code><code><span class="constructor">Generated</span> <span class="keyword">of</span> <a href="index.html#type-lrng">lrng</a></code></td></tr><tr id="type-lrng.Range" class="anchored"><td class="def constructor"><a href="#type-lrng.Range" class="anchor"></a><code>| </code><code><span class="constructor">Range</span> <span class="keyword">of</span> Stdlib.Lexing.position * Stdlib.Lexing.position</code></td></tr></table></dt></dl><dl><dt class="spec exception" id="exception-Parse_error_locn"><a href="#exception-Parse_error_locn" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Parse_error_locn</span> <span class="keyword">of</span> <a href="index.html#type-lrng">lrng</a> * string</code></dt></dl><dl><dt class="spec value" id="val-pp_lpos"><a href="#val-pp_lpos" class="anchor"></a><code><span class="keyword">val</span> pp_lpos : Stdlib.Lexing.position <span>&#45;&gt;</span> PPrint.document</code></dt><dt class="spec value" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span class="keyword">val</span> pp_lrng : <a href="index.html#type-lrng">lrng</a> <span>&#45;&gt;</span> PPrint.document</code></dt></dl><dl><dt class="spec type" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span class="keyword">type</span> bvmanyarith</code><code> = Isla_lang__Isla_lang_ast.bvmanyarith</code><code> = </code><table class="variant"><tr id="type-bvmanyarith.Bvand" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code>| </code><code><span class="constructor">Bvand</span></code></td></tr><tr id="type-bvmanyarith.Bvor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code>| </code><code><span class="constructor">Bvor</span></code></td></tr><tr id="type-bvmanyarith.Bvxor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxor</span></code></td></tr><tr id="type-bvmanyarith.Bvadd" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code>| </code><code><span class="constructor">Bvadd</span></code></td></tr><tr id="type-bvmanyarith.Bvmul" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code>| </code><code><span class="constructor">Bvmul</span></code></td></tr></table></dt><dt class="spec type" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span class="keyword">type</span> bvcomp</code><code> = Isla_lang__Isla_lang_ast.bvcomp</code><code> = </code><table class="variant"><tr id="type-bvcomp.Bvult" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvult" class="anchor"></a><code>| </code><code><span class="constructor">Bvult</span></code></td></tr><tr id="type-bvcomp.Bvslt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code>| </code><code><span class="constructor">Bvslt</span></code></td></tr><tr id="type-bvcomp.Bvule" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvule" class="anchor"></a><code>| </code><code><span class="constructor">Bvule</span></code></td></tr><tr id="type-bvcomp.Bvsle" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code>| </code><code><span class="constructor">Bvsle</span></code></td></tr><tr id="type-bvcomp.Bvuge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code>| </code><code><span class="constructor">Bvuge</span></code></td></tr><tr id="type-bvcomp.Bvsge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code>| </code><code><span class="constructor">Bvsge</span></code></td></tr><tr id="type-bvcomp.Bvugt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code>| </code><code><span class="constructor">Bvugt</span></code></td></tr><tr id="type-bvcomp.Bvsgt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code>| </code><code><span class="constructor">Bvsgt</span></code></td></tr></table></dt><dt class="spec type" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span class="keyword">type</span> bvarith</code><code> = Isla_lang__Isla_lang_ast.bvarith</code><code> = </code><table class="variant"><tr id="type-bvarith.Bvnand" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnand" class="anchor"></a><code>| </code><code><span class="constructor">Bvnand</span></code></td></tr><tr id="type-bvarith.Bvnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvnor</span></code></td></tr><tr id="type-bvarith.Bvxnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxnor</span></code></td></tr><tr id="type-bvarith.Bvsub" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsub" class="anchor"></a><code>| </code><code><span class="constructor">Bvsub</span></code></td></tr><tr id="type-bvarith.Bvudiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvudiv</span></code></td></tr><tr id="type-bvarith.Bvudivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvudivi</span></code></td></tr><tr id="type-bvarith.Bvsdiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdiv</span></code></td></tr><tr id="type-bvarith.Bvsdivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdivi</span></code></td></tr><tr id="type-bvarith.Bvurem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvurem" class="anchor"></a><code>| </code><code><span class="constructor">Bvurem</span></code></td></tr><tr id="type-bvarith.Bvsrem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code>| </code><code><span class="constructor">Bvsrem</span></code></td></tr><tr id="type-bvarith.Bvsmod" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmod</span></code></td></tr><tr id="type-bvarith.Bvshl" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvshl" class="anchor"></a><code>| </code><code><span class="constructor">Bvshl</span></code></td></tr><tr id="type-bvarith.Bvlshr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code>| </code><code><span class="constructor">Bvlshr</span></code></td></tr><tr id="type-bvarith.Bvashr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvashr" class="anchor"></a><code>| </code><code><span class="constructor">Bvashr</span></code></td></tr></table></dt><dt class="spec type" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span class="keyword">type</span> manyop</code><code> = Isla_lang__Isla_lang_ast.manyop</code><code> = </code><table class="variant"><tr id="type-manyop.And" class="anchored"><td class="def constructor"><a href="#type-manyop.And" class="anchor"></a><code>| </code><code><span class="constructor">And</span></code></td></tr><tr id="type-manyop.Or" class="anchored"><td class="def constructor"><a href="#type-manyop.Or" class="anchor"></a><code>| </code><code><span class="constructor">Or</span></code></td></tr><tr id="type-manyop.Bvmanyarith" class="anchored"><td class="def constructor"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="index.html#type-bvmanyarith">bvmanyarith</a></code></td></tr><tr id="type-manyop.Concat" class="anchored"><td class="def constructor"><a href="#type-manyop.Concat" class="anchor"></a><code>| </code><code><span class="constructor">Concat</span></code></td></tr></table></dt><dt class="spec type" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span class="keyword">type</span> unop</code><code> = Isla_lang__Isla_lang_ast.unop</code><code> = </code><table class="variant"><tr id="type-unop.Not" class="anchored"><td class="def constructor"><a href="#type-unop.Not" class="anchor"></a><code>| </code><code><span class="constructor">Not</span></code></td></tr><tr id="type-unop.Bvnot" class="anchored"><td class="def constructor"><a href="#type-unop.Bvnot" class="anchor"></a><code>| </code><code><span class="constructor">Bvnot</span></code></td></tr><tr id="type-unop.Bvredand" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredand" class="anchor"></a><code>| </code><code><span class="constructor">Bvredand</span></code></td></tr><tr id="type-unop.Bvredor" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredor" class="anchor"></a><code>| </code><code><span class="constructor">Bvredor</span></code></td></tr><tr id="type-unop.Bvneg" class="anchored"><td class="def constructor"><a href="#type-unop.Bvneg" class="anchor"></a><code>| </code><code><span class="constructor">Bvneg</span></code></td></tr><tr id="type-unop.Extract" class="anchored"><td class="def constructor"><a href="#type-unop.Extract" class="anchor"></a><code>| </code><code><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-unop.ZeroExtend" class="anchored"><td class="def constructor"><a href="#type-unop.ZeroExtend" class="anchor"></a><code>| </code><code><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-unop.SignExtend" class="anchored"><td class="def constructor"><a href="#type-unop.SignExtend" class="anchor"></a><code>| </code><code><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span class="keyword">type</span> binop</code><code> = Isla_lang__Isla_lang_ast.binop</code><code> = </code><table class="variant"><tr id="type-binop.Eq" class="anchored"><td class="def constructor"><a href="#type-binop.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span></code></td></tr><tr id="type-binop.Bvarith" class="anchored"><td class="def constructor"><a href="#type-binop.Bvarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="index.html#type-bvarith">bvarith</a></code></td></tr><tr id="type-binop.Bvcomp" class="anchored"><td class="def constructor"><a href="#type-binop.Bvcomp" class="anchor"></a><code>| </code><code><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="index.html#type-bvcomp">bvcomp</a></code></td></tr></table></dt><dt class="spec type" id="type-accessor"><a href="#type-accessor" class="anchor"></a><code><span class="keyword">type</span> accessor</code><code> = Isla_lang__Isla_lang_ast.accessor</code><code> = </code><table class="variant"><tr id="type-accessor.Field" class="anchored"><td class="def constructor"><a href="#type-accessor.Field" class="anchor"></a><code>| </code><code><span class="constructor">Field</span> <span class="keyword">of</span> string</code></td></tr></table></dt><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> ty</code><code> = Isla_lang__Isla_lang_ast.ty</code><code> = </code><table class="variant"><tr id="type-ty.Ty_Bool" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Bool</span></code></td></tr><tr id="type-ty.Ty_BitVec" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code>| </code><code><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Enum" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Array" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Array" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <a href="index.html#type-ty">ty</a> * <a href="index.html#type-ty">ty</a></code></td></tr></table></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>'a exp</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.exp</span></code><code> = </code><table class="variant"><tr id="type-exp.Var" class="anchored"><td class="def constructor"><a href="#type-exp.Var" class="anchor"></a><code>| </code><code><span class="constructor">Var</span> <span class="keyword">of</span> int * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bits" class="anchored"><td class="def constructor"><a href="#type-exp.Bits" class="anchor"></a><code>| </code><code><span class="constructor">Bits</span> <span class="keyword">of</span> string * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bool" class="anchored"><td class="def constructor"><a href="#type-exp.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Enum" class="anchored"><td class="def constructor"><a href="#type-exp.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Unop" class="anchored"><td class="def constructor"><a href="#type-exp.Unop" class="anchor"></a><code>| </code><code><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Binop" class="anchored"><td class="def constructor"><a href="#type-exp.Binop" class="anchor"></a><code>| </code><code><span class="constructor">Binop</span> <span class="keyword">of</span> <a href="index.html#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Manyop" class="anchored"><td class="def constructor"><a href="#type-exp.Manyop" class="anchor"></a><code>| </code><code><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Ite" class="anchored"><td class="def constructor"><a href="#type-exp.Ite" class="anchor"></a><code>| </code><code><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-valu"><a href="#type-valu" class="anchor"></a><code><span class="keyword">type</span> valu</code><code> = Isla_lang__Isla_lang_ast.valu</code><code> = </code><table class="variant"><tr id="type-valu.Val_Symbolic" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Symbolic" class="anchor"></a><code>| </code><code><span class="constructor">Val_Symbolic</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-valu.Val_Bool" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Val_Bool</span> <span class="keyword">of</span> bool</code></td></tr><tr id="type-valu.Val_I" class="anchored"><td class="def constructor"><a href="#type-valu.Val_I" class="anchor"></a><code>| </code><code><span class="constructor">Val_I</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-valu.Val_Bits" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Bits" class="anchor"></a><code>| </code><code><span class="constructor">Val_Bits</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu.Val_Enum" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Val_Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a></code></td></tr><tr id="type-valu.Val_String" class="anchored"><td class="def constructor"><a href="#type-valu.Val_String" class="anchor"></a><code>| </code><code><span class="constructor">Val_String</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu.Val_Unit" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Unit" class="anchor"></a><code>| </code><code><span class="constructor">Val_Unit</span></code></td></tr><tr id="type-valu.Val_NamedUnit" class="anchored"><td class="def constructor"><a href="#type-valu.Val_NamedUnit" class="anchor"></a><code>| </code><code><span class="constructor">Val_NamedUnit</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu.Val_Vector" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Vector" class="anchor"></a><code>| </code><code><span class="constructor">Val_Vector</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu.Val_List" class="anchored"><td class="def constructor"><a href="#type-valu.Val_List" class="anchor"></a><code>| </code><code><span class="constructor">Val_List</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu.Val_Struct" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Struct" class="anchor"></a><code>| </code><code><span class="constructor">Val_Struct</span> <span class="keyword">of</span> <span><span>(string * <a href="index.html#type-valu">valu</a>)</span> list</span></code></td></tr><tr id="type-valu.Val_Poison" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Poison" class="anchor"></a><code>| </code><code><span class="constructor">Val_Poison</span></code></td></tr></table></dt><dt class="spec type" id="type-accessor_list"><a href="#type-accessor_list" class="anchor"></a><code><span class="keyword">type</span> accessor_list</code><code> = Isla_lang__Isla_lang_ast.accessor_list</code><code> = </code><table class="variant"><tr id="type-accessor_list.Nil" class="anchored"><td class="def constructor"><a href="#type-accessor_list.Nil" class="anchor"></a><code>| </code><code><span class="constructor">Nil</span></code></td></tr><tr id="type-accessor_list.Cons" class="anchored"><td class="def constructor"><a href="#type-accessor_list.Cons" class="anchor"></a><code>| </code><code><span class="constructor">Cons</span> <span class="keyword">of</span> <span><a href="index.html#type-accessor">accessor</a> list</span></code></td></tr></table></dt><dt class="spec type" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span class="keyword">type</span> <span>'a smt</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.smt</span></code><code> = </code><table class="variant"><tr id="type-smt.DeclareConst" class="anchored"><td class="def constructor"><a href="#type-smt.DeclareConst" class="anchor"></a><code>| </code><code><span class="constructor">DeclareConst</span> <span class="keyword">of</span> int * <a href="index.html#type-ty">ty</a></code></td></tr><tr id="type-smt.DefineConst" class="anchored"><td class="def constructor"><a href="#type-smt.DefineConst" class="anchor"></a><code>| </code><code><span class="constructor">DefineConst</span> <span class="keyword">of</span> int * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Assert" class="anchored"><td class="def constructor"><a href="#type-smt.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.DefineEnum" class="anchored"><td class="def constructor"><a href="#type-smt.DefineEnum" class="anchor"></a><code>| </code><code><span class="constructor">DefineEnum</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-valu_option"><a href="#type-valu_option" class="anchor"></a><code><span class="keyword">type</span> valu_option</code><code> = <span><a href="index.html#type-valu">valu</a> option</span></code></dt><dt class="spec type" id="type-valu_concrete"><a href="#type-valu_concrete" class="anchor"></a><code><span class="keyword">type</span> valu_concrete</code><code> = Isla_lang__Isla_lang_ast.valu_concrete</code><code> = </code><table class="variant"><tr id="type-valu_concrete.CVal_Bool" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Bool" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Bool</span> <span class="keyword">of</span> bool</code></td></tr><tr id="type-valu_concrete.CVal_I" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_I" class="anchor"></a><code>| </code><code><span class="constructor">CVal_I</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-valu_concrete.CVal_Bits" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Bits" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Bits</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu_concrete.CVal_Enum" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Enum" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a></code></td></tr><tr id="type-valu_concrete.CVal_String" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_String" class="anchor"></a><code>| </code><code><span class="constructor">CVal_String</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu_concrete.CVal_Unit" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Unit" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Unit</span></code></td></tr><tr id="type-valu_concrete.CVal_NamedUnit" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_NamedUnit" class="anchor"></a><code>| </code><code><span class="constructor">CVal_NamedUnit</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu_concrete.CVal_Vector" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Vector" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Vector</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu_concrete.CVal_List" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_List" class="anchor"></a><code>| </code><code><span class="constructor">CVal_List</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu_concrete.CVal_Struct" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Struct" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Struct</span> <span class="keyword">of</span> <span><span>(string * <a href="index.html#type-valu">valu</a>)</span> list</span></code></td></tr><tr id="type-valu_concrete.CVal_Poison" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Poison" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Poison</span></code></td></tr></table></dt><dt class="spec type" id="type-event"><a href="#type-event" class="anchor"></a><code><span class="keyword">type</span> <span>'a event</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.event</span></code><code> = </code><table class="variant"><tr id="type-event.Smt" class="anchored"><td class="def constructor"><a href="#type-event.Smt" class="anchor"></a><code>| </code><code><span class="constructor">Smt</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-smt">smt</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Branch" class="anchored"><td class="def constructor"><a href="#type-event.Branch" class="anchor"></a><code>| </code><code><span class="constructor">Branch</span> <span class="keyword">of</span> int * string * <span class="type-var">'a</span></code></td></tr><tr id="type-event.ReadReg" class="anchored"><td class="def constructor"><a href="#type-event.ReadReg" class="anchor"></a><code>| </code><code><span class="constructor">ReadReg</span> <span class="keyword">of</span> string * <a href="index.html#type-accessor_list">accessor_list</a> * <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.WriteReg" class="anchored"><td class="def constructor"><a href="#type-event.WriteReg" class="anchor"></a><code>| </code><code><span class="constructor">WriteReg</span> <span class="keyword">of</span> string * <a href="index.html#type-accessor_list">accessor_list</a> * <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.ReadMem" class="anchored"><td class="def constructor"><a href="#type-event.ReadMem" class="anchor"></a><code>| </code><code><span class="constructor">ReadMem</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * int * <a href="index.html#type-valu_option">valu_option</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.WriteMem" class="anchored"><td class="def constructor"><a href="#type-event.WriteMem" class="anchor"></a><code>| </code><code><span class="constructor">WriteMem</span> <span class="keyword">of</span> int * <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * int * <a href="index.html#type-valu_option">valu_option</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.BranchAddress" class="anchored"><td class="def constructor"><a href="#type-event.BranchAddress" class="anchor"></a><code>| </code><code><span class="constructor">BranchAddress</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Barrier" class="anchored"><td class="def constructor"><a href="#type-event.Barrier" class="anchor"></a><code>| </code><code><span class="constructor">Barrier</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.CacheOp" class="anchored"><td class="def constructor"><a href="#type-event.CacheOp" class="anchor"></a><code>| </code><code><span class="constructor">CacheOp</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.MarkReg" class="anchored"><td class="def constructor"><a href="#type-event.MarkReg" class="anchor"></a><code>| </code><code><span class="constructor">MarkReg</span> <span class="keyword">of</span> string * string * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Cycle" class="anchored"><td class="def constructor"><a href="#type-event.Cycle" class="anchor"></a><code>| </code><code><span class="constructor">Cycle</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr><tr id="type-event.Instr" class="anchored"><td class="def constructor"><a href="#type-event.Instr" class="anchor"></a><code>| </code><code><span class="constructor">Instr</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Sleeping" class="anchored"><td class="def constructor"><a href="#type-event.Sleeping" class="anchor"></a><code>| </code><code><span class="constructor">Sleeping</span> <span class="keyword">of</span> int * <span class="type-var">'a</span></code></td></tr><tr id="type-event.WakeRequest" class="anchored"><td class="def constructor"><a href="#type-event.WakeRequest" class="anchor"></a><code>| </code><code><span class="constructor">WakeRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr><tr id="type-event.SleepRequest" class="anchored"><td class="def constructor"><a href="#type-event.SleepRequest" class="anchor"></a><code>| </code><code><span class="constructor">SleepRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-trc"><a href="#type-trc" class="anchor"></a><code><span class="keyword">type</span> <span>'a trc</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.trc</span></code><code> = </code><table class="variant"><tr id="type-trc.Trace" class="anchored"><td class="def constructor"><a href="#type-trc.Trace" class="anchor"></a><code>| </code><code><span class="constructor">Trace</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="index.html#type-event">event</a></span> list</span></code></td></tr></table></dt><dt class="spec type" id="type-exp_val"><a href="#type-exp_val" class="anchor"></a><code><span class="keyword">type</span> <span>'a exp_val</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.exp_val</span></code><code> = </code><table class="variant"><tr id="type-exp_val.EV_Bits" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Bits" class="anchor"></a><code>| </code><code><span class="constructor">EV_Bits</span> <span class="keyword">of</span> string * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Bool" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Bool" class="anchor"></a><code>| </code><code><span class="constructor">EV_Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Enum" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Enum" class="anchor"></a><code>| </code><code><span class="constructor">EV_Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Unop" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Unop" class="anchor"></a><code>| </code><code><span class="constructor">EV_Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Binop" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Binop" class="anchor"></a><code>| </code><code><span class="constructor">EV_Binop</span> <span class="keyword">of</span> <a href="index.html#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Manyop" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Manyop" class="anchor"></a><code>| </code><code><span class="constructor">EV_Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Ite" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Ite" class="anchor"></a><code>| </code><code><span class="constructor">EV_Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt></dl></details></div></div></div><div class="spec module" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span class="keyword">module</span> Lexer = Isla_lang.Lexer</code></div><div class="spec module" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span class="keyword">module</span> Parser = Isla_lang.Parser</code></div><dl><dt class="spec type" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span class="keyword">type</span> loc</code><code> = Stdlib.Lexing.position</code></dt><dt class="spec type" id="type-rtrc"><a href="#type-rtrc" class="anchor"></a><code><span class="keyword">type</span> rtrc</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-trc">trc</a></span></code></dt><dd><p>The type of raw traces out of the parser</p></dd></dl><dl><dt class="spec type" id="type-revent"><a href="#type-revent" class="anchor"></a><code><span class="keyword">type</span> revent</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-event">event</a></span></code></dt><dd><p>The type of raw events out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span class="keyword">type</span> rsmt</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-smt">smt</a></span></code></dt><dd><p>The type of raw SMT declaration out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span class="keyword">type</span> rexp</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-exp">exp</a></span></code></dt><dd><p>The type of raw expressions out of the parser</p></dd></dl></section><section><header><h2 id="islatrace-parsing"><a href="#islatrace-parsing" class="anchor"></a>IslaTrace parsing</h2></header><dl><dt class="spec exception" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla parsing error</p></dd></dl><dl><dt class="spec exception" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">LexError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla lexing error</p></dd></dl><dl><dt class="spec type" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span class="keyword">type</span> lexer</code><code> = Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#module-Parser">Parser</a>.token</code></dt><dt class="spec type" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span class="keyword">type</span> <span>'a parser</span></code><code> = <a href="index.html#type-lexer">lexer</a> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec value" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span class="keyword">val</span> parse : <span><span class="type-var">'a</span> <a href="index.html#type-parser">parser</a></span> <span>&#45;&gt;</span> <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-parse_exp"><a href="#val-parse_exp" class="anchor"></a><code><span class="keyword">val</span> parse_exp : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-rexp">rexp</a></code></dt><dd><p>Parse a single Isla expression from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span class="keyword">val</span> parse_exp_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-rexp">rexp</a></code></dt><dd><p>Parse a single Isla expression from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span class="keyword">val</span> parse_exp_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <a href="index.html#type-rexp">rexp</a></code></dt><dd><p>Parse a single Isla expression from a channel</p></dd></dl><dl><dt class="spec value" id="val-parse_trc"><a href="#val-parse_trc" class="anchor"></a><code><span class="keyword">val</span> parse_trc : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-rtrc">rtrc</a></code></dt><dd><p>Parse an Isla trace from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-parse_trc_string"><a href="#val-parse_trc_string" class="anchor"></a><code><span class="keyword">val</span> parse_trc_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-rtrc">rtrc</a></code></dt><dd><p>Parse an Isla trace from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_trc_channel"><a href="#val-parse_trc_channel" class="anchor"></a><code><span class="keyword">val</span> parse_trc_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <a href="index.html#type-rtrc">rtrc</a></code></dt><dd><p>Parse an Isla trace from a channel</p></dd></dl></section><section><header><h2 id="islatrace-pretty-printing"><a href="#islatrace-pretty-printing" class="anchor"></a>IslaTrace pretty printing</h2></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Isla_lang.PP</code></span></summary><dl><dt class="spec value" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span class="keyword">val</span> pp_raw_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum : Isla_lang__.Isla_lang_ast.enum <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span class="keyword">val</span> pp_raw_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span class="keyword">val</span> pp_raw_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_ty : Isla_lang__.Isla_lang_ast.ty <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_unop : Isla_lang__.Isla_lang_ast.unop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvarith : Isla_lang__.Isla_lang_ast.bvarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvcomp : Isla_lang__.Isla_lang_ast.bvcomp <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binop : Isla_lang__.Isla_lang_ast.binop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvmanyarith : Isla_lang__.Isla_lang_ast.bvmanyarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_manyop : Isla_lang__.Isla_lang_ast.manyop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp_val"><a href="#val-pp_raw_exp_val" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp_val : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp_val</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.smt</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_valu"><a href="#val-pp_raw_valu" class="anchor"></a><code><span class="keyword">val</span> pp_raw_valu : Isla_lang__.Isla_lang_ast.valu <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_selem"><a href="#val-pp_raw_selem" class="anchor"></a><code><span class="keyword">val</span> pp_raw_selem : <span>(string * Isla_lang__.Isla_lang_ast.valu)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_valu_concrete"><a href="#val-pp_raw_valu_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_raw_valu_concrete : Isla_lang__.Isla_lang_ast.valu_concrete <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_selem_concrete"><a href="#val-pp_raw_selem_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_raw_selem_concrete : <span>(string * Isla_lang__.Isla_lang_ast.valu_concrete)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_accessor"><a href="#val-pp_raw_accessor" class="anchor"></a><code><span class="keyword">val</span> pp_raw_accessor : Isla_lang__.Isla_lang_ast.accessor <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_accessor_list"><a href="#val-pp_raw_accessor_list" class="anchor"></a><code><span class="keyword">val</span> pp_raw_accessor_list : Isla_lang__.Isla_lang_ast.accessor_list <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_valu_option"><a href="#val-pp_raw_valu_option" class="anchor"></a><code><span class="keyword">val</span> pp_raw_valu_option : Isla_lang__.Isla_lang_ast.valu_option <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_event"><a href="#val-pp_raw_event" class="anchor"></a><code><span class="keyword">val</span> pp_raw_event : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.event</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_trc"><a href="#val-pp_raw_trc" class="anchor"></a><code><span class="keyword">val</span> pp_raw_trc : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.trc</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span class="keyword">val</span> pp_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span class="keyword">val</span> pp_enum : Isla_lang__.Isla_lang_ast.enum <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span class="keyword">val</span> pp_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span class="keyword">val</span> pp_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span class="keyword">val</span> pp_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span class="keyword">val</span> pp_j : int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span class="keyword">val</span> pp_ty : Isla_lang__.Isla_lang_ast.ty <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span class="keyword">val</span> pp_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span class="keyword">val</span> pp_unop : Isla_lang__.Isla_lang_ast.unop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvarith : Isla_lang__.Isla_lang_ast.bvarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_bvcomp : Isla_lang__.Isla_lang_ast.bvcomp <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span class="keyword">val</span> pp_binop : Isla_lang__.Isla_lang_ast.binop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvmanyarith : Isla_lang__.Isla_lang_ast.bvmanyarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_manyop : Isla_lang__.Isla_lang_ast.manyop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp_val"><a href="#val-pp_exp_val" class="anchor"></a><code><span class="keyword">val</span> pp_exp_val : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp_val</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.smt</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_valu"><a href="#val-pp_valu" class="anchor"></a><code><span class="keyword">val</span> pp_valu : Isla_lang__.Isla_lang_ast.valu <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_selem"><a href="#val-pp_selem" class="anchor"></a><code><span class="keyword">val</span> pp_selem : <span>(string * Isla_lang__.Isla_lang_ast.valu)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_valu_concrete"><a href="#val-pp_valu_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_valu_concrete : Isla_lang__.Isla_lang_ast.valu_concrete <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_selem_concrete"><a href="#val-pp_selem_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_selem_concrete : <span>(string * Isla_lang__.Isla_lang_ast.valu_concrete)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_accessor"><a href="#val-pp_accessor" class="anchor"></a><code><span class="keyword">val</span> pp_accessor : Isla_lang__.Isla_lang_ast.accessor <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_accessor_list"><a href="#val-pp_accessor_list" class="anchor"></a><code><span class="keyword">val</span> pp_accessor_list : Isla_lang__.Isla_lang_ast.accessor_list <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_valu_option"><a href="#val-pp_valu_option" class="anchor"></a><code><span class="keyword">val</span> pp_valu_option : Isla_lang__.Isla_lang_ast.valu_option <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span class="keyword">val</span> pp_event : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.event</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_trc"><a href="#val-pp_trc" class="anchor"></a><code><span class="keyword">val</span> pp_trc : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.trc</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></details></div></div></div></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Isla.Base)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Base</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Base</span></code></h1><p>This module wraps all <code>isla-lang</code> functionality. No other module should directly touch the <code>Isla_lang</code> module.</p><p>The isla trace syntax is compose of <a href="#type-event" title="event">events</a> that a regrouped into <a href="#type-trc" title="trc">traces</a>. There are a lot of possible events, and some of them are unsupported. in particular all the ones that deal with concurrency.</p><p>All the variable in isla traces are numbered. They are named <code>v28</code> in the syntax and are represented as a plain <code>int</code> in Ocaml. The structure of the traces is a mix of SMT declaration about those variable and actual processor events. SMT declaration use SMT expressions of type <a href="#type-exp"><code>exp</code></a> which entirely distinct from <a href="../../Ast/index.html#type-exp"><code>Ast.exp</code></a> (Use <a href="../Conv/index.html"><code>Isla.Conv</code></a> to convert). On the contrary processor event do not contain direct SMT expressions but Sail values of type <a href="#type-valu"><code>valu</code></a>. A <a href="#type-valu"><code>valu</code></a> can be either a single symbolic variable, a concrete bitvector/boolean/enumeration value or a more complex sail structure with fields that contain other <a href="#type-valu"><code>valu</code></a>s and some other things.</p><p>Event of reading and writing complex register like <code>PSTATE</code> in <code>AArch64</code> will provide the whole structure as a valu to be read or written. However, Those events may contain a accessor list that implies that only specific field of the struct are written or read. This useful, because of the flat representation of registers in <a href="../../State/Reg/index.html"><code>State.Reg</code></a>: each field is considered to be a separate register.</p><p>The isla types are polymorphic over the annotation because that comes from <code>isla-lang</code>, but in practice the only annotation I use the source position of type <a href="#type-lrng"><code>lrng</code></a>, that's why there is a set of aliases starting with <code>r</code>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#aliases">Aliases</a></li><li><a href="#islatrace-parsing">IslaTrace parsing</a></li><li><a href="#islatrace-pretty-printing">IslaTrace pretty printing</a></li></ul></nav></div><div class="odoc-content"><h2 id="aliases"><a href="#aliases" class="anchor"></a>Aliases</h2><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Isla_lang</span>.AST <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span><span class="keyword">type</span> lrng</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.lrng</span><span> = </span></code><ol><li id="type-lrng.UnknownRng" class="def variant constructor anchored"><a href="#type-lrng.UnknownRng" class="anchor"></a><code><span>| </span><span><span class="constructor">UnknownRng</span></span></code></li><li id="type-lrng.Generated" class="def variant constructor anchored"><a href="#type-lrng.Generated" class="anchor"></a><code><span>| </span><span><span class="constructor">Generated</span> <span class="keyword">of</span> <a href="#type-lrng">lrng</a></span></code></li><li id="type-lrng.Range" class="def variant constructor anchored"><a href="#type-lrng.Range" class="anchor"></a><code><span>| </span><span><span class="constructor">Range</span> <span class="keyword">of</span> <span class="xref-unresolved">Stdlib</span>.Lexing.position * <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Parse_error_locn"><a href="#exception-Parse_error_locn" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Parse_error_locn</span> <span class="keyword">of</span> <a href="#type-lrng">lrng</a> * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_lpos"><a href="#val-pp_lpos" class="anchor"></a><code><span><span class="keyword">val</span> pp_lpos : <span><span class="xref-unresolved">Stdlib</span>.Lexing.position <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span><span class="keyword">val</span> pp_lrng : <span><a href="#type-lrng">lrng</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-accessor"><a href="#type-accessor" class="anchor"></a><code><span><span class="keyword">type</span> accessor</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.accessor</span><span> = </span></code><ol><li id="type-accessor.Field" class="def variant constructor anchored"><a href="#type-accessor.Field" class="anchor"></a><code><span>| </span><span><span class="constructor">Field</span> <span class="keyword">of</span> string</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span><span class="keyword">type</span> bvarith</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.bvarith</span><span> = </span></code><ol><li id="type-bvarith.Bvnand" class="def variant constructor anchored"><a href="#type-bvarith.Bvnand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnand</span></span></code></li><li id="type-bvarith.Bvnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnor</span></span></code></li><li id="type-bvarith.Bvxnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxnor</span></span></code></li><li id="type-bvarith.Bvsub" class="def variant constructor anchored"><a href="#type-bvarith.Bvsub" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsub</span></span></code></li><li id="type-bvarith.Bvudiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudiv</span></span></code></li><li id="type-bvarith.Bvudivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudivi</span></span></code></li><li id="type-bvarith.Bvsdiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdiv</span></span></code></li><li id="type-bvarith.Bvsdivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdivi</span></span></code></li><li id="type-bvarith.Bvurem" class="def variant constructor anchored"><a href="#type-bvarith.Bvurem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvurem</span></span></code></li><li id="type-bvarith.Bvsrem" class="def variant constructor anchored"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsrem</span></span></code></li><li id="type-bvarith.Bvsmod" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmod</span></span></code></li><li id="type-bvarith.Bvshl" class="def variant constructor anchored"><a href="#type-bvarith.Bvshl" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvshl</span></span></code></li><li id="type-bvarith.Bvlshr" class="def variant constructor anchored"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvlshr</span></span></code></li><li id="type-bvarith.Bvashr" class="def variant constructor anchored"><a href="#type-bvarith.Bvashr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvashr</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span><span class="keyword">type</span> bvcomp</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.bvcomp</span><span> = </span></code><ol><li id="type-bvcomp.Bvult" class="def variant constructor anchored"><a href="#type-bvcomp.Bvult" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvult</span></span></code></li><li id="type-bvcomp.Bvslt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvslt</span></span></code></li><li id="type-bvcomp.Bvule" class="def variant constructor anchored"><a href="#type-bvcomp.Bvule" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvule</span></span></code></li><li id="type-bvcomp.Bvsle" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsle</span></span></code></li><li id="type-bvcomp.Bvuge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuge</span></span></code></li><li id="type-bvcomp.Bvsge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsge</span></span></code></li><li id="type-bvcomp.Bvugt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvugt</span></span></code></li><li id="type-bvcomp.Bvsgt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsgt</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span><span class="keyword">type</span> bvmanyarith</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.bvmanyarith</span><span> = </span></code><ol><li id="type-bvmanyarith.Bvand" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvand</span></span></code></li><li id="type-bvmanyarith.Bvor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvor</span></span></code></li><li id="type-bvmanyarith.Bvxor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxor</span></span></code></li><li id="type-bvmanyarith.Bvadd" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvadd</span></span></code></li><li id="type-bvmanyarith.Bvmul" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmul</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-accessor_list"><a href="#type-accessor_list" class="anchor"></a><code><span><span class="keyword">type</span> accessor_list</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.accessor_list</span><span> = </span></code><ol><li id="type-accessor_list.Nil" class="def variant constructor anchored"><a href="#type-accessor_list.Nil" class="anchor"></a><code><span>| </span><span><span class="constructor">Nil</span></span></code></li><li id="type-accessor_list.Cons" class="def variant constructor anchored"><a href="#type-accessor_list.Cons" class="anchor"></a><code><span>| </span><span><span class="constructor">Cons</span> <span class="keyword">of</span> <span><a href="#type-accessor">accessor</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span><span class="keyword">type</span> unop</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.unop</span><span> = </span></code><ol><li id="type-unop.Not" class="def variant constructor anchored"><a href="#type-unop.Not" class="anchor"></a><code><span>| </span><span><span class="constructor">Not</span></span></code></li><li id="type-unop.Bvnot" class="def variant constructor anchored"><a href="#type-unop.Bvnot" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnot</span></span></code></li><li id="type-unop.Bvredand" class="def variant constructor anchored"><a href="#type-unop.Bvredand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredand</span></span></code></li><li id="type-unop.Bvredor" class="def variant constructor anchored"><a href="#type-unop.Bvredor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredor</span></span></code></li><li id="type-unop.Bvneg" class="def variant constructor anchored"><a href="#type-unop.Bvneg" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvneg</span></span></code></li><li id="type-unop.Extract" class="def variant constructor anchored"><a href="#type-unop.Extract" class="anchor"></a><code><span>| </span><span><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-unop.ZeroExtend" class="def variant constructor anchored"><a href="#type-unop.ZeroExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</span></code></li><li id="type-unop.SignExtend" class="def variant constructor anchored"><a href="#type-unop.SignExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span><span class="keyword">type</span> binop</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.binop</span><span> = </span></code><ol><li id="type-binop.Eq" class="def variant constructor anchored"><a href="#type-binop.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span></span></code></li><li id="type-binop.Bvarith" class="def variant constructor anchored"><a href="#type-binop.Bvarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="#type-bvarith">bvarith</a></span></code></li><li id="type-binop.Bvcomp" class="def variant constructor anchored"><a href="#type-binop.Bvcomp" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="#type-bvcomp">bvcomp</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span><span class="keyword">type</span> manyop</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.manyop</span><span> = </span></code><ol><li id="type-manyop.And" class="def variant constructor anchored"><a href="#type-manyop.And" class="anchor"></a><code><span>| </span><span><span class="constructor">And</span></span></code></li><li id="type-manyop.Or" class="def variant constructor anchored"><a href="#type-manyop.Or" class="anchor"></a><code><span>| </span><span><span class="constructor">Or</span></span></code></li><li id="type-manyop.Bvmanyarith" class="def variant constructor anchored"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="#type-bvmanyarith">bvmanyarith</a></span></code></li><li id="type-manyop.Concat" class="def variant constructor anchored"><a href="#type-manyop.Concat" class="anchor"></a><code><span>| </span><span><span class="constructor">Concat</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-base_val"><a href="#type-base_val" class="anchor"></a><code><span><span class="keyword">type</span> base_val</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.base_val</span><span> = </span></code><ol><li id="type-base_val.Val_Symbolic" class="def variant constructor anchored"><a href="#type-base_val.Val_Symbolic" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Symbolic</span> <span class="keyword">of</span> int</span></code></li><li id="type-base_val.Val_Bool" class="def variant constructor anchored"><a href="#type-base_val.Val_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Bool</span> <span class="keyword">of</span> bool</span></code></li><li id="type-base_val.Val_Bits" class="def variant constructor anchored"><a href="#type-base_val.Val_Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Bits</span> <span class="keyword">of</span> string</span></code></li><li id="type-base_val.Val_Enum" class="def variant constructor anchored"><a href="#type-base_val.Val_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-assume_val"><a href="#type-assume_val" class="anchor"></a><code><span><span class="keyword">type</span> assume_val</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.assume_val</span><span> = </span></code><ol><li id="type-assume_val.AVal_Var" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Var" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Var</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a></span></code></li><li id="type-assume_val.AVal_Bool" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Bool</span> <span class="keyword">of</span> bool</span></code></li><li id="type-assume_val.AVal_Bits" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Bits</span> <span class="keyword">of</span> string</span></code></li><li id="type-assume_val.AVal_Enum" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> ty</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.ty</span><span> = </span></code><ol><li id="type-ty.Ty_Bool" class="def variant constructor anchored"><a href="#type-ty.Ty_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Bool</span></span></code></li><li id="type-ty.Ty_BitVec" class="def variant constructor anchored"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Enum" class="def variant constructor anchored"><a href="#type-ty.Ty_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Array" class="def variant constructor anchored"><a href="#type-ty.Ty_Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <a href="#type-ty">ty</a> * <a href="#type-ty">ty</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a exp</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.exp</span></span><span> = </span></code><ol><li id="type-exp.Val" class="def variant constructor anchored"><a href="#type-exp.Val" class="anchor"></a><code><span>| </span><span><span class="constructor">Val</span> <span class="keyword">of</span> <a href="#type-base_val">base_val</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Unop" class="def variant constructor anchored"><a href="#type-exp.Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Binop" class="def variant constructor anchored"><a href="#type-exp.Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">Binop</span> <span class="keyword">of</span> <a href="#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Manyop" class="def variant constructor anchored"><a href="#type-exp.Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Ite" class="def variant constructor anchored"><a href="#type-exp.Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-valu"><a href="#type-valu" class="anchor"></a><code><span><span class="keyword">type</span> valu</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.valu</span><span> = </span></code><ol><li id="type-valu.RegVal_Base" class="def variant constructor anchored"><a href="#type-valu.RegVal_Base" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Base</span> <span class="keyword">of</span> <a href="#type-base_val">base_val</a></span></code></li><li id="type-valu.RegVal_I" class="def variant constructor anchored"><a href="#type-valu.RegVal_I" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_I</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-valu.RegVal_String" class="def variant constructor anchored"><a href="#type-valu.RegVal_String" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_String</span> <span class="keyword">of</span> string</span></code></li><li id="type-valu.RegVal_Unit" class="def variant constructor anchored"><a href="#type-valu.RegVal_Unit" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Unit</span></span></code></li><li id="type-valu.RegVal_Vector" class="def variant constructor anchored"><a href="#type-valu.RegVal_Vector" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Vector</span> <span class="keyword">of</span> <span><a href="#type-valu">valu</a> list</span></span></code></li><li id="type-valu.RegVal_List" class="def variant constructor anchored"><a href="#type-valu.RegVal_List" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_List</span> <span class="keyword">of</span> <span><a href="#type-valu">valu</a> list</span></span></code></li><li id="type-valu.RegVal_Struct" class="def variant constructor anchored"><a href="#type-valu.RegVal_Struct" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Struct</span> <span class="keyword">of</span> <span><span>(string * <a href="#type-valu">valu</a>)</span> list</span></span></code></li><li id="type-valu.RegVal_Constructor" class="def variant constructor anchored"><a href="#type-valu.RegVal_Constructor" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Constructor</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a></span></code></li><li id="type-valu.RegVal_Poison" class="def variant constructor anchored"><a href="#type-valu.RegVal_Poison" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Poison</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-a_exp"><a href="#type-a_exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a a_exp</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.a_exp</span></span><span> = </span></code><ol><li id="type-a_exp.AExp_Val" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Val" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Val</span> <span class="keyword">of</span> <a href="#type-assume_val">assume_val</a> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Unop" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Binop" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Binop</span> <span class="keyword">of</span> <a href="#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Manyop" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Ite" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a smt</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.smt</span></span><span> = </span></code><ol><li id="type-smt.DeclareConst" class="def variant constructor anchored"><a href="#type-smt.DeclareConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DeclareConst</span> <span class="keyword">of</span> int * <a href="#type-ty">ty</a></span></code></li><li id="type-smt.DefineConst" class="def variant constructor anchored"><a href="#type-smt.DefineConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineConst</span> <span class="keyword">of</span> int * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Assert" class="def variant constructor anchored"><a href="#type-smt.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.DefineEnum" class="def variant constructor anchored"><a href="#type-smt.DefineEnum" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineEnum</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-arg_list"><a href="#type-arg_list" class="anchor"></a><code><span><span class="keyword">type</span> arg_list</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.arg_list</span><span> = </span></code><ol><li id="type-arg_list.NilArgs" class="def variant constructor anchored"><a href="#type-arg_list.NilArgs" class="anchor"></a><code><span>| </span><span><span class="constructor">NilArgs</span></span></code></li><li id="type-arg_list.ListArgs" class="def variant constructor anchored"><a href="#type-arg_list.ListArgs" class="anchor"></a><code><span>| </span><span><span class="constructor">ListArgs</span> <span class="keyword">of</span> <span><a href="#type-valu">valu</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tag_value"><a href="#type-tag_value" class="anchor"></a><code><span><span class="keyword">type</span> tag_value</span><span> = <span><a href="#type-valu">valu</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-segment"><a href="#type-segment" class="anchor"></a><code><span><span class="keyword">type</span> segment</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.segment</span><span> = </span></code><ol><li id="type-segment.Segment" class="def variant constructor anchored"><a href="#type-segment.Segment" class="anchor"></a><code><span>| </span><span><span class="constructor">Segment</span> <span class="keyword">of</span> string * int * int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-event"><a href="#type-event" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a event</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.event</span></span><span> = </span></code><ol><li id="type-event.Smt" class="def variant constructor anchored"><a href="#type-event.Smt" class="anchor"></a><code><span>| </span><span><span class="constructor">Smt</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-smt">smt</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-event.Branch" class="def variant constructor anchored"><a href="#type-event.Branch" class="anchor"></a><code><span>| </span><span><span class="constructor">Branch</span> <span class="keyword">of</span> int * string * <span class="type-var">'a</span></span></code></li><li id="type-event.ReadReg" class="def variant constructor anchored"><a href="#type-event.ReadReg" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadReg</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.WriteReg" class="def variant constructor anchored"><a href="#type-event.WriteReg" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteReg</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.ReadMem" class="def variant constructor anchored"><a href="#type-event.ReadMem" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadMem</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * int * <a href="#type-tag_value">tag_value</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.WriteMem" class="def variant constructor anchored"><a href="#type-event.WriteMem" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteMem</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * int * <a href="#type-tag_value">tag_value</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.BranchAddress" class="def variant constructor anchored"><a href="#type-event.BranchAddress" class="anchor"></a><code><span>| </span><span><span class="constructor">BranchAddress</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.Barrier" class="def variant constructor anchored"><a href="#type-event.Barrier" class="anchor"></a><code><span>| </span><span><span class="constructor">Barrier</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.CacheOp" class="def variant constructor anchored"><a href="#type-event.CacheOp" class="anchor"></a><code><span>| </span><span><span class="constructor">CacheOp</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.MarkReg" class="def variant constructor anchored"><a href="#type-event.MarkReg" class="anchor"></a><code><span>| </span><span><span class="constructor">MarkReg</span> <span class="keyword">of</span> string * string * <span class="type-var">'a</span></span></code></li><li id="type-event.Cycle" class="def variant constructor anchored"><a href="#type-event.Cycle" class="anchor"></a><code><span>| </span><span><span class="constructor">Cycle</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li><li id="type-event.Instr" class="def variant constructor anchored"><a href="#type-event.Instr" class="anchor"></a><code><span>| </span><span><span class="constructor">Instr</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.Sleeping" class="def variant constructor anchored"><a href="#type-event.Sleeping" class="anchor"></a><code><span>| </span><span><span class="constructor">Sleeping</span> <span class="keyword">of</span> int * <span class="type-var">'a</span></span></code></li><li id="type-event.WakeRequest" class="def variant constructor anchored"><a href="#type-event.WakeRequest" class="anchor"></a><code><span>| </span><span><span class="constructor">WakeRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li><li id="type-event.SleepRequest" class="def variant constructor anchored"><a href="#type-event.SleepRequest" class="anchor"></a><code><span>| </span><span><span class="constructor">SleepRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li><li id="type-event.AssumeReg" class="def variant constructor anchored"><a href="#type-event.AssumeReg" class="anchor"></a><code><span>| </span><span><span class="constructor">AssumeReg</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.Assume" class="def variant constructor anchored"><a href="#type-event.Assume" class="anchor"></a><code><span>| </span><span><span class="constructor">Assume</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-event.FunAssume" class="def variant constructor anchored"><a href="#type-event.FunAssume" class="anchor"></a><code><span>| </span><span><span class="constructor">FunAssume</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.UseFunAssume" class="def variant constructor anchored"><a href="#type-event.UseFunAssume" class="anchor"></a><code><span>| </span><span><span class="constructor">UseFunAssume</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.AbstractCall" class="def variant constructor anchored"><a href="#type-event.AbstractCall" class="anchor"></a><code><span>| </span><span><span class="constructor">AbstractCall</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.AbstractPrimop" class="def variant constructor anchored"><a href="#type-event.AbstractPrimop" class="anchor"></a><code><span>| </span><span><span class="constructor">AbstractPrimop</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-instruction_segments"><a href="#type-instruction_segments" class="anchor"></a><code><span><span class="keyword">type</span> instruction_segments</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.instruction_segments</span><span> = </span></code><ol><li id="type-instruction_segments.Segments" class="def variant constructor anchored"><a href="#type-instruction_segments.Segments" class="anchor"></a><code><span>| </span><span><span class="constructor">Segments</span> <span class="keyword">of</span> <span><a href="#type-segment">segment</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trc"><a href="#type-trc" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a trc</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.trc</span></span><span> = </span></code><ol><li id="type-trc.Trace" class="def variant constructor anchored"><a href="#type-trc.Trace" class="anchor"></a><code><span>| </span><span><span class="constructor">Trace</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="#type-event">event</a></span> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-maybe_fork"><a href="#type-maybe_fork" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a maybe_fork</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.maybe_fork</span></span><span> = </span></code><ol><li id="type-maybe_fork.Cases" class="def variant constructor anchored"><a href="#type-maybe_fork.Cases" class="anchor"></a><code><span>| </span><span><span class="constructor">Cases</span> <span class="keyword">of</span> string * <span><span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span> list</span></span></code></li><li id="type-maybe_fork.End" class="def variant constructor anchored"><a href="#type-maybe_fork.End" class="anchor"></a><code><span>| </span><span><span class="constructor">End</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tree_trc"><a href="#type-tree_trc" class="anchor"></a><code><span><span class="keyword">and</span> <span>!'a tree_trc</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.tree_trc</span></span><span> = </span></code><ol><li id="type-tree_trc.TreeTrace" class="def variant constructor anchored"><a href="#type-tree_trc.TreeTrace" class="anchor"></a><code><span>| </span><span><span class="constructor">TreeTrace</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="#type-event">event</a></span> list</span> * <span><span class="type-var">'a</span> <a href="#type-maybe_fork">maybe_fork</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trcs"><a href="#type-trcs" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a trcs</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.trcs</span></span><span> = </span></code><ol><li id="type-trcs.Traces" class="def variant constructor anchored"><a href="#type-trcs.Traces" class="anchor"></a><code><span>| </span><span><span class="constructor">Traces</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span> list</span></span></code></li><li id="type-trcs.TracesWithSegments" class="def variant constructor anchored"><a href="#type-trcs.TracesWithSegments" class="anchor"></a><code><span>| </span><span><span class="constructor">TracesWithSegments</span> <span class="keyword">of</span> <a href="#type-instruction_segments">instruction_segments</a> * <span><span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-whole_tree"><a href="#type-whole_tree" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a whole_tree</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.whole_tree</span></span><span> = </span></code><ol><li id="type-whole_tree.BareTree" class="def variant constructor anchored"><a href="#type-whole_tree.BareTree" class="anchor"></a><code><span>| </span><span><span class="constructor">BareTree</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span></span></code></li><li id="type-whole_tree.TreeWithSegments" class="def variant constructor anchored"><a href="#type-whole_tree.TreeWithSegments" class="anchor"></a><code><span>| </span><span><span class="constructor">TreeWithSegments</span> <span class="keyword">of</span> <a href="#type-instruction_segments">instruction_segments</a> * <span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_base_val"><a href="#val-subst_val_base_val" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_base_val : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-base_val">base_val</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_exp"><a href="#val-subst_val_exp" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_exp : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_valu"><a href="#val-subst_val_valu" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_valu : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-valu">valu</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-valu">valu</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_smt"><a href="#val-subst_val_smt" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_smt : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-smt">smt</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-smt">smt</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_arg_list"><a href="#val-subst_val_arg_list" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_arg_list : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-arg_list">arg_list</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-arg_list">arg_list</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_event"><a href="#val-subst_val_event" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_event : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-event">event</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-event">event</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_tree_trc"><a href="#val-subst_val_tree_trc" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_tree_trc : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_maybe_fork"><a href="#val-subst_val_maybe_fork" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_maybe_fork : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-maybe_fork">maybe_fork</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-maybe_fork">maybe_fork</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_trc"><a href="#val-subst_val_trc" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_trc : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_whole_tree"><a href="#val-subst_val_whole_tree" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_whole_tree : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-whole_tree">whole_tree</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-whole_tree">whole_tree</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_trcs"><a href="#val-subst_val_trcs" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_trcs : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-trcs">trcs</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-trcs">trcs</a></span></span></code></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span><span class="keyword">module</span> Lexer</span><span> = <span class="xref-unresolved">Isla_lang</span>.Lexer</span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span><span class="keyword">module</span> Parser</span><span> = <span class="xref-unresolved">Isla_lang</span>.Parser</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span><span class="keyword">type</span> loc</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rtrc"><a href="#type-rtrc" class="anchor"></a><code><span><span class="keyword">type</span> rtrc</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-trc">trc</a></span></span></code></div><div class="spec-doc"><p>The type of raw traces out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-revent"><a href="#type-revent" class="anchor"></a><code><span><span class="keyword">type</span> revent</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-event">event</a></span></span></code></div><div class="spec-doc"><p>The type of raw events out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span><span class="keyword">type</span> rsmt</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-smt">smt</a></span></span></code></div><div class="spec-doc"><p>The type of raw SMT declaration out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span><span class="keyword">type</span> rexp</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-exp">exp</a></span></span></code></div><div class="spec-doc"><p>The type of raw expressions out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rtrcs"><a href="#type-rtrcs" class="anchor"></a><code><span><span class="keyword">type</span> rtrcs</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-trcs">trcs</a></span></span></code></div></div><h2 id="islatrace-parsing"><a href="#islatrace-parsing" class="anchor"></a>IslaTrace parsing</h2><div class="odoc-spec"><div class="spec exception anchored" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla parsing error</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">LexError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla lexing error</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span><span class="keyword">type</span> lexer</span><span> = <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Parser</span>.token</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a parser</span></span><span> = <span><a href="#type-lexer">lexer</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span><span class="keyword">val</span> parse : <span><span><span class="type-var">'a</span> <a href="#type-parser">parser</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp"><a href="#val-parse_exp" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-rexp">rexp</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-rexp">rexp</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_channel : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-rexp">rexp</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trc"><a href="#val-parse_trc" class="anchor"></a><code><span><span class="keyword">val</span> parse_trc : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrc">rtrc</a></span></code></div><div class="spec-doc"><p>Parse an Isla trace from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trc_string"><a href="#val-parse_trc_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_trc_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrc">rtrc</a></span></code></div><div class="spec-doc"><p>Parse an Isla trace from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trc_channel"><a href="#val-parse_trc_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_trc_channel : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrc">rtrc</a></span></code></div><div class="spec-doc"><p>Parse an Isla trace from a channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trcs"><a href="#val-parse_trcs" class="anchor"></a><code><span><span class="keyword">val</span> parse_trcs : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.lrng <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trcs</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trcs_string"><a href="#val-parse_trcs_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_trcs_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrcs">rtrcs</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trcs_channel"><a href="#val-parse_trcs_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_trcs_channel : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrcs">rtrcs</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_segments"><a href="#val-parse_segments" class="anchor"></a><code><span><span class="keyword">val</span> parse_segments : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-instruction_segments">instruction_segments</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_segments_string"><a href="#val-parse_segments_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_segments_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-instruction_segments">instruction_segments</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_segments_channel"><a href="#val-parse_segments_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_segments_channel : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-instruction_segments">instruction_segments</a></span></code></div></div><h2 id="islatrace-pretty-printing"><a href="#islatrace-pretty-printing" class="anchor"></a>IslaTrace pretty printing</h2><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Isla_lang</span>.PP <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.enum <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_nat"><a href="#val-pp_raw_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_ty : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.ty <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_unop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.unop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvarith : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvarith <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvcomp : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvcomp <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.binop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvmanyarith : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvmanyarith <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_manyop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.manyop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_base_val"><a href="#val-pp_raw_base_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_base_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.base_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_assume_val"><a href="#val-pp_raw_assume_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_assume_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.assume_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_a_exp"><a href="#val-pp_raw_a_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_a_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.a_exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.smt</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_valu"><a href="#val-pp_raw_valu" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_valu : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_selem"><a href="#val-pp_raw_selem" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_selem : <span><span>(string * <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_accessor"><a href="#val-pp_raw_accessor" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_accessor : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_accessor_list"><a href="#val-pp_raw_accessor_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_accessor_list : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor_list <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_arg_list"><a href="#val-pp_raw_arg_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_arg_list : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.arg_list <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_tag_value"><a href="#val-pp_raw_tag_value" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_tag_value : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tag_value <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_event"><a href="#val-pp_raw_event" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_event : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.event</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_segment"><a href="#val-pp_raw_segment" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_segment : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.segment <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_instruction_segments"><a href="#val-pp_raw_instruction_segments" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_instruction_segments : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.instruction_segments <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_trc"><a href="#val-pp_raw_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_trcs"><a href="#val-pp_raw_trcs" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_trcs : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trcs</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_maybe_fork"><a href="#val-pp_raw_maybe_fork" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_maybe_fork : 
+  <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.maybe_fork</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_tree_trc"><a href="#val-pp_raw_tree_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_tree_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tree_trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_whole_tree"><a href="#val-pp_raw_whole_tree" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_whole_tree : 
+  <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.whole_tree</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.enum <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_nat"><a href="#val-pp_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span><span class="keyword">val</span> pp_j : <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_ty : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.ty <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_unop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.unop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvarith : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvarith <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvcomp : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvcomp <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_binop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.binop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvmanyarith : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvmanyarith <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_manyop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.manyop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_base_val"><a href="#val-pp_base_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_base_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.base_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_assume_val"><a href="#val-pp_assume_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_assume_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.assume_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_a_exp"><a href="#val-pp_a_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_a_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.a_exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.smt</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_valu"><a href="#val-pp_valu" class="anchor"></a><code><span><span class="keyword">val</span> pp_valu : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_selem"><a href="#val-pp_selem" class="anchor"></a><code><span><span class="keyword">val</span> pp_selem : <span><span>(string * <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_accessor"><a href="#val-pp_accessor" class="anchor"></a><code><span><span class="keyword">val</span> pp_accessor : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_accessor_list"><a href="#val-pp_accessor_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_accessor_list : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor_list <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_arg_list"><a href="#val-pp_arg_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_arg_list : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.arg_list <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_tag_value"><a href="#val-pp_tag_value" class="anchor"></a><code><span><span class="keyword">val</span> pp_tag_value : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tag_value <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span><span class="keyword">val</span> pp_event : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.event</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_segment"><a href="#val-pp_segment" class="anchor"></a><code><span><span class="keyword">val</span> pp_segment : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.segment <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_instruction_segments"><a href="#val-pp_instruction_segments" class="anchor"></a><code><span><span class="keyword">val</span> pp_instruction_segments : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.instruction_segments <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_trc"><a href="#val-pp_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_trcs"><a href="#val-pp_trcs" class="anchor"></a><code><span><span class="keyword">val</span> pp_trcs : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trcs</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_maybe_fork"><a href="#val-pp_maybe_fork" class="anchor"></a><code><span><span class="keyword">val</span> pp_maybe_fork : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.maybe_fork</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_tree_trc"><a href="#val-pp_tree_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_tree_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tree_trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_whole_tree"><a href="#val-pp_whole_tree" class="anchor"></a><code><span><span class="keyword">val</span> pp_whole_tree : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.whole_tree</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div></details></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Cache/Epoch/index.html b/doc/html/read-dwarf/Isla/Cache/Epoch/index.html
index f04929de..a1a49fdd 100644
--- a/doc/html/read-dwarf/Isla/Cache/Epoch/index.html
+++ b/doc/html/read-dwarf/Isla/Cache/Epoch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Epoch (read-dwarf.Isla.Cache.Epoch)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Epoch</nav><h1>Module <code>Cache.Epoch</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = string * int * string</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <span>(string * int * string)</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> string * int * string</code></dt><dt class="spec value" id="val-of_config"><a href="#val-of_config" class="anchor"></a><code><span class="keyword">val</span> of_config : <a href="../../../Config__File/ArchConf/Isla/index.html#type-t">Server.Config.t</a> <span>&#45;&gt;</span> string * int * string</code></dt><dd><p>Build the epoch from the config. This function does the config <code>Digest</code></p></dd></dl><dl><dt class="spec value" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span class="keyword">val</span> compat : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Epoch (read-dwarf.Isla.Cache.Epoch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Epoch</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.Epoch</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = string * int * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(string * int * string)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> string * int * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_config"><a href="#val-of_config" class="anchor"></a><code><span><span class="keyword">val</span> of_config : <span><a href="../../../Config/File/ArchConf/Isla/index.html#type-t">Config.File.ArchConf.Isla.t</a> <span class="arrow">&#45;&gt;</span></span> string * int * string</span></code></div><div class="spec-doc"><p>Build the epoch from the config. This function does the config <code>Digest</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span><span class="keyword">val</span> compat : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Cache/IC/index.html b/doc/html/read-dwarf/Isla/Cache/IC/index.html
index 382b1443..3fac4151 100644
--- a/doc/html/read-dwarf/Isla/Cache/IC/index.html
+++ b/doc/html/read-dwarf/Isla/Cache/IC/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IC (read-dwarf.Isla.Cache.IC)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; IC</nav><h1>Module <code>Cache.IC</code></h1><p>The isla cache module</p></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../Opcode/index.html#type-t">Opcode.t</a></code></dt><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code><code> = <a href="../TraceList/index.html#type-t">TraceList.t</a></code></dt><dt class="spec type" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span class="keyword">type</span> epoch</code><code> = <a href="../Epoch/index.html#type-t">Epoch.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../Utils__Cache/Make/index.html#type-t">Utils__Cache.Make(Opcode)(TraceList)(Epoch).t</a></code></dt></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-epoch">epoch</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IC (read-dwarf.Isla.Cache.IC)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; IC</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.IC</span></code></h1><p>The isla cache module</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../Opcode/index.html#type-t">Opcode.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span><span> = <a href="../TraceList/index.html#type-t">TraceList.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span><span class="keyword">type</span> epoch</span><span> = <a href="../Epoch/index.html#type-t">Epoch.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-epoch">epoch</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Cache/Opcode/index.html b/doc/html/read-dwarf/Isla/Cache/Opcode/index.html
index 4c58297c..69c4ebd7 100644
--- a/doc/html/read-dwarf/Isla/Cache/Opcode/index.html
+++ b/doc/html/read-dwarf/Isla/Cache/Opcode/index.html
@@ -1,2 +1,8 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Opcode (read-dwarf.Isla.Cache.Opcode)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Opcode</nav><h1>Module <code>Cache.Opcode</code></h1><p>Implementation of <span class="xref-unresolved" title="unresolved reference to &quot;Cache.Key&quot;"><a href="../../index.html#module-Cache"><code>Cache</code></a>.Key</span> for opcodes.</p><p>It is a special encoding of BytesSeq. If it is short enough to fit in the hash, then we do it. Otherwise we store in a file.</p><p>The exact encoding is here (back mean the last/top bit of the integer, i.e. <span class="xref-unresolved" title="unresolved reference to &quot;IntBits.back&quot;"><code>IntBits</code>.back</span>):</p><p>Short encoding: bit 0 to back -3 : The data bit back -3 to back: The size of the data bit back : cleared</p><p>Long encoding: bit 0 to back -1 : The start of the data bit back -1: set</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span></code></dt></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span> <span>&#45;&gt;</span> <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span> <span>&#45;&gt;</span> <a href="../../../Utils/IntBits/index.html#type-t">Utils.IntBits.t</a></code></dt><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : <a href="../../../Utils/IntBits/index.html#type-t">Utils.IntBits.t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> option</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Opcode (read-dwarf.Isla.Cache.Opcode)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Opcode</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.Opcode</span></code></h1><p>Implementation of <code>Cache.Key</code> for opcodes.</p><p>It is a special encoding of BytesSeq. If it is short enough to fit in the hash, then we do it. Otherwise we store in a file.</p><p>The exact encoding is here (back mean the last/top bit of the integer, i.e. <code>IntBits.back</code>):</p><p>Short encoding: bit 0 to back -3 : The data bit back -3 to back: The size of the data bit back : cleared</p><p>Long encoding: bit 0 to back -1 : The start of the data bit back -1: set</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><a href="../../Server/index.html#type-opcode">Server.opcode</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reloc_id"><a href="#val-reloc_id" class="anchor"></a><code><span><span class="keyword">val</span> reloc_id : <span><span><a href="../../Relocation/index.html#type-t">Relocation.t</a> option</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reloc_of_id"><a href="#val-reloc_of_id" class="anchor"></a><code><span><span class="keyword">val</span> reloc_of_id : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Relocation/index.html#type-t">Relocation.t</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : 
+  <span><span><span>(<a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span class="type-var">'a</span>)</span> option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span class="type-var">'a</span>)</span> option</span> <span class="arrow">&#45;&gt;</span></span>
+  bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_enough"><a href="#val-small_enough" class="anchor"></a><code><span><span class="keyword">val</span> small_enough : <span><a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><span><span>(<a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span><a href="../../Relocation/index.html#type-t">Relocation.t</a> option</span>)</span> option</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/IntBits/index.html#type-t">Utils.IntBits.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span><a href="../../Relocation/index.html#type-t">Relocation.t</a> option</span>)</span> option</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : 
+  <span><a href="../../../Utils/IntBits/index.html#type-t">Utils.IntBits.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span><a href="../../Relocation/index.html#type-t">Relocation.t</a> option</span>)</span> option</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Cache/TraceList/index.html b/doc/html/read-dwarf/Isla/Cache/TraceList/index.html
index f1e7394b..3f2e335d 100644
--- a/doc/html/read-dwarf/Isla/Cache/TraceList/index.html
+++ b/doc/html/read-dwarf/Isla/Cache/TraceList/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TraceList (read-dwarf.Isla.Cache.TraceList)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; TraceList</nav><h1>Module <code>Cache.TraceList</code></h1><p>Representation of trace lists on disk.</p><p>It is just a list of traces separated by new lines</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><a href="../../Base/index.html#type-rtrc">Base.rtrc</a> list</span></code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TraceList (read-dwarf.Isla.Cache.TraceList)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; TraceList</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.TraceList</span></code></h1><p>Representation of trace lists on disk.</p><p>It is just a list of traces separated by new lines</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <a href="../../Base/index.html#type-rtrcs">Base.rtrcs</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Cache/index.html b/doc/html/read-dwarf/Isla/Cache/index.html
index 2b8f0e57..532df455 100644
--- a/doc/html/read-dwarf/Isla/Cache/index.html
+++ b/doc/html/read-dwarf/Isla/Cache/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Isla.Cache)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Cache</nav><h1>Module <code>Isla.Cache</code></h1><p>This module provide a caching system for isla trace on top of <a href="../Server/index.html"><code>Server</code></a>.</p><p>It uses the cache named &quot;isla&quot; of <a href="index.html"><code>Cache</code></a></p><p>Call <a href="index.html#val-start"><code>start</code></a> to start and <a href="index.html#val-stop"><code>stop</code></a>. Do not interact directly with the <a href="../Server/index.html"><code>Server</code></a> if you use the cache.</p><p>You can use <a href="index.html#val-ensure_started"><code>ensure_started</code></a> to force the <a href="../Server/index.html"><code>Server</code></a> to start but you probably shouldn't do that. By the default the <a href="../Server/index.html"><code>Server</code></a> is only started if the traces of an instruction are required and not in the cache.</p></header><dl><dt class="spec type" id="type-config"><a href="#type-config" class="anchor"></a><code><span class="keyword">type</span> config</code><code> = <a href="../Server/index.html#type-config">Server.config</a></code></dt><dd><p>The type of Isla configuration</p></dd></dl><dl><dt class="spec module" id="module-Opcode"><a href="#module-Opcode" class="anchor"></a><code><span class="keyword">module</span> <a href="Opcode/index.html">Opcode</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Implementation of <span class="xref-unresolved" title="unresolved reference to &quot;Cache.Key&quot;"><a href="../index.html#module-Cache"><code>Cache</code></a>.Key</span> for opcodes.</p></dd></dl><dl><dt class="spec module" id="module-TraceList"><a href="#module-TraceList" class="anchor"></a><code><span class="keyword">module</span> <a href="TraceList/index.html">TraceList</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Representation of trace lists on disk.</p></dd></dl><dl><dt class="spec value" id="val-epoch"><a href="#val-epoch" class="anchor"></a><code><span class="keyword">val</span> epoch : int</code></dt><dd><p>An epoch independant of the isla version, bump if you change the representation of the traces on disk.</p><p>Reset (or not) when bumping isla version (<a href="../Server/index.html#val-required_version"><code>Server.required_version</code></a>)</p><p>The Epoch also include the digest of the Isla configuration. Any change of configuration will wipe out the cache.</p></dd></dl><div class="spec module" id="module-Epoch"><a href="#module-Epoch" class="anchor"></a><code><span class="keyword">module</span> <a href="Epoch/index.html">Epoch</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec module" id="module-IC"><a href="#module-IC" class="anchor"></a><code><span class="keyword">module</span> <a href="IC/index.html">IC</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The isla cache module</p></dd></dl><dl><dt class="spec value" id="val-cache"><a href="#val-cache" class="anchor"></a><code><span class="keyword">val</span> cache : <span><span><span>(<a href="IC/index.html#type-t">IC.t</a> * <a href="index.html#type-config">config</a>)</span> option</span> Stdlib.ref</span></code></dt><dd><p>This varaible stores the cache RAM representation</p></dd></dl><dl><dt class="spec value" id="val-configr"><a href="#val-configr" class="anchor"></a><code><span class="keyword">val</span> configr : <span><span><a href="index.html#type-config">config</a> option</span> Stdlib.ref</span></code></dt><dd><p>If this is set and cache is also set, then the server should be started with the architecture inside this variable when required</p></dd></dl><dl><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : <a href="index.html#type-config">config</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Start the caching system. Do not yet start the server</p></dd></dl><dl><dt class="spec value" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span class="keyword">val</span> stop : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop the caching system, stop the server if it was started</p></dd></dl><dl><dt class="spec value" id="val-ensure_started"><a href="#val-ensure_started" class="anchor"></a><code><span class="keyword">val</span> ensure_started : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Start the server if not already started</p></dd></dl><dl><dt class="spec value" id="val-get_cache"><a href="#val-get_cache" class="anchor"></a><code><span class="keyword">val</span> get_cache : unit <span>&#45;&gt;</span> <a href="IC/index.html#type-t">IC.t</a> * <a href="index.html#type-config">config</a></code></dt><dd><p>Get the cache and fails if the cache wasn't started</p></dd></dl><dl><dt class="spec value" id="val-get_traces"><a href="#val-get_traces" class="anchor"></a><code><span class="keyword">val</span> get_traces : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Base/index.html#type-rtrc">Base.rtrc</a> list</span></code></dt><dd><p>Get the traces of the opcode given. Use <a href="../Server/index.html"><code>Server</code></a> if the value is not in the cache</p></dd></dl><dl><dt class="spec value" id="val-get_nop"><a href="#val-get_nop" class="anchor"></a><code><span class="keyword">val</span> get_nop : unit <span>&#45;&gt;</span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a></code></dt><dd><p>Get the traces of the nop opcode (The initialization code). Use <a href="../Server/index.html"><code>Server</code></a> if the value is not in the cache</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Isla.Cache)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Cache</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Cache</span></code></h1><p>This module provide a caching system for isla trace on top of <a href="../Server/index.html"><code>Server</code></a>.</p><p>It uses the cache named &quot;isla&quot; of <a href="#"><code>Cache</code></a></p><p>Call <a href="#val-start"><code>start</code></a> to start and <a href="#val-stop"><code>stop</code></a>. Do not interact directly with the <a href="../Server/index.html"><code>Server</code></a> if you use the cache.</p><p>You can use <a href="#val-ensure_started"><code>ensure_started</code></a> to force the <a href="../Server/index.html"><code>Server</code></a> to start but you probably shouldn't do that. By the default the <a href="../Server/index.html"><code>Server</code></a> is only started if the traces of an instruction are required and not in the cache.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-config"><a href="#type-config" class="anchor"></a><code><span><span class="keyword">type</span> config</span><span> = <a href="../Server/index.html#type-config">Server.config</a></span></code></div><div class="spec-doc"><p>The type of Isla configuration</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Opcode"><a href="#module-Opcode" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Opcode/index.html">Opcode</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Implementation of <code>Cache.Key</code> for opcodes.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-TraceList"><a href="#module-TraceList" class="anchor"></a><code><span><span class="keyword">module</span> <a href="TraceList/index.html">TraceList</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Representation of trace lists on disk.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-epoch"><a href="#val-epoch" class="anchor"></a><code><span><span class="keyword">val</span> epoch : int</span></code></div><div class="spec-doc"><p>An epoch independant of the isla version, bump if you change the representation of the traces on disk.</p><p>Reset (or not) when bumping isla version (<a href="../Server/index.html#val-required_version"><code>Server.required_version</code></a>)</p><p>The Epoch also include the digest of the Isla configuration. Any change of configuration will wipe out the cache.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Epoch"><a href="#module-Epoch" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Epoch/index.html">Epoch</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-IC"><a href="#module-IC" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IC/index.html">IC</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The isla cache module</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cache"><a href="#val-cache" class="anchor"></a><code><span><span class="keyword">val</span> cache : <span><span><span>(<a href="IC/index.html#type-t">IC.t</a> * <a href="#type-config">config</a>)</span> option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>This varaible stores the cache RAM representation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-configr"><a href="#val-configr" class="anchor"></a><code><span><span class="keyword">val</span> configr : <span><span><a href="#type-config">config</a> option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>If this is set and cache is also set, then the server should be started with the architecture inside this variable when required</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span><a href="#type-config">config</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start the caching system. Do not yet start the server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span><span class="keyword">val</span> stop : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop the caching system, stop the server if it was started</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_started"><a href="#val-ensure_started" class="anchor"></a><code><span><span class="keyword">val</span> ensure_started : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start the server if not already started</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_cache"><a href="#val-get_cache" class="anchor"></a><code><span><span class="keyword">val</span> get_cache : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="IC/index.html#type-t">IC.t</a> * <a href="#type-config">config</a></span></code></div><div class="spec-doc"><p>Get the cache and fails if the cache wasn't started</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_traces"><a href="#val-get_traces" class="anchor"></a><code><span><span class="keyword">val</span> get_traces : <span><a href="../Server/index.html#type-opcode">Server.opcode</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-rtrcs">Base.rtrcs</a></span></code></div><div class="spec-doc"><p>Get the traces of the opcode given. Use <a href="../Server/index.html"><code>Server</code></a> if the value is not in the cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_nop"><a href="#val-get_nop" class="anchor"></a><code><span><span class="keyword">val</span> get_nop : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a></span></code></div><div class="spec-doc"><p>Get the traces of the nop opcode (The initialization code). Use <a href="../Server/index.html"><code>Server</code></a> if the value is not in the cache</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Conv/index.html b/doc/html/read-dwarf/Isla/Conv/index.html
index fc8e32c7..50a552b6 100644
--- a/doc/html/read-dwarf/Isla/Conv/index.html
+++ b/doc/html/read-dwarf/Isla/Conv/index.html
@@ -1,2 +1,11 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Conv (read-dwarf.Isla.Conv)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Conv</nav><h1>Module <code>Isla.Conv</code></h1></header><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></code></dt><dt class="spec value" id="val-unop"><a href="#val-unop" class="anchor"></a><code><span class="keyword">val</span> unop : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.unop <span>&#45;&gt;</span> <a href="../../Ast/index.html#type-unop">Ast.unop</a></code></dt><dt class="spec value" id="val-bvarith"><a href="#val-bvarith" class="anchor"></a><code><span class="keyword">val</span> bvarith : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.bvarith <span>&#45;&gt;</span> <a href="../../Ast/index.html#type-bvarith">Ast.bvarith</a></code></dt><dt class="spec value" id="val-bvcomp"><a href="#val-bvcomp" class="anchor"></a><code><span class="keyword">val</span> bvcomp : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.bvcomp <span>&#45;&gt;</span> <a href="../../Ast/index.html#type-bvcomp">Ast.bvcomp</a></code></dt><dt class="spec value" id="val-bvmanyarith"><a href="#val-bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> bvmanyarith : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.bvmanyarith <span>&#45;&gt;</span> <a href="../../Ast/index.html#type-bvmanyarith">Ast.bvmanyarith</a></code></dt><dt class="spec value" id="val-binop"><a href="#val-binop" class="anchor"></a><code><span class="keyword">val</span> binop : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.binop <span>&#45;&gt;</span> <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span></code></dt><dt class="spec value" id="val-manyop"><a href="#val-manyop" class="anchor"></a><code><span class="keyword">val</span> manyop : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.manyop <span>&#45;&gt;</span> <a href="../../Ast/index.html#type-manyop">Ast.manyop</a></code></dt><dt class="spec value" id="val-direct_exp_no_var"><a href="#val-direct_exp_no_var" class="anchor"></a><code><span class="keyword">val</span> direct_exp_no_var : <span>(<span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></code></dt><dt class="spec value" id="val-exp_var_conv"><a href="#val-exp_var_conv" class="anchor"></a><code><span class="keyword">val</span> exp_var_conv : <span>(int <span>&#45;&gt;</span> <span class="type-var">'v</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></code></dt><dt class="spec value" id="val-exp"><a href="#val-exp" class="anchor"></a><code><span class="keyword">val</span> exp : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, int, <span class="type-var">'b</span>, <span class="type-var">'c</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></code></dt><dt class="spec value" id="val-exp_var_subst"><a href="#val-exp_var_subst" class="anchor"></a><code><span class="keyword">val</span> exp_var_subst : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></code></dt><dd><p>Convert an expression from isla to Ast but using a var-to-exp conversion function</p></dd></dl><dl><dt class="spec value" id="val-exp_add_type_var_subst"><a href="#val-exp_add_type_var_subst" class="anchor"></a><code><span class="keyword">val</span> exp_add_type_var_subst : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dd><p>Convert directly from an untyped isla expression to an <a href="../../Exp/Typed/index.html"><code>Exp.Typed</code></a> by substituing isla variables with already typed expressions</p></dd></dl><dl><dt class="spec value" id="val-smt_var_conv"><a href="#val-smt_var_conv" class="anchor"></a><code><span class="keyword">val</span> smt_var_conv : <span>(int <span>&#45;&gt;</span> <span class="type-var">'v</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.smt</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-smt">Ast.smt</a></span></code></dt><dt class="spec value" id="val-smt"><a href="#val-smt" class="anchor"></a><code><span class="keyword">val</span> smt : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.smt</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, int, <span class="type-var">'b</span>, <span class="type-var">'c</span>)</span> <a href="../../Ast/index.html#type-smt">Ast.smt</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Conv (read-dwarf.Isla.Conv)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Conv</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Conv</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="../Base/index.html#type-ty">Base.ty</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unop"><a href="#val-unop" class="anchor"></a><code><span><span class="keyword">val</span> unop : <span><a href="../Base/index.html#type-unop">Base.unop</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ast/index.html#type-unop">Ast.unop</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bvarith"><a href="#val-bvarith" class="anchor"></a><code><span><span class="keyword">val</span> bvarith : <span><a href="../Base/index.html#type-bvarith">Base.bvarith</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ast/index.html#type-bvarith">Ast.bvarith</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bvcomp"><a href="#val-bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> bvcomp : <span><a href="../Base/index.html#type-bvcomp">Base.bvcomp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ast/index.html#type-bvcomp">Ast.bvcomp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bvmanyarith"><a href="#val-bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> bvmanyarith : <span><a href="../Base/index.html#type-bvmanyarith">Base.bvmanyarith</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ast/index.html#type-bvmanyarith">Ast.bvmanyarith</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-binop"><a href="#val-binop" class="anchor"></a><code><span><span class="keyword">val</span> binop : <span><a href="../Base/index.html#type-binop">Base.binop</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-binop">Ast.binop</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-manyop"><a href="#val-manyop" class="anchor"></a><code><span><span class="keyword">val</span> manyop : <span><a href="../Base/index.html#type-manyop">Base.manyop</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ast/index.html#type-manyop">Ast.manyop</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_no_var"><a href="#val-direct_exp_no_var" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_no_var : 
+  <span><span>(<span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_var_conv"><a href="#val-exp_var_conv" class="anchor"></a><code><span><span class="keyword">val</span> exp_var_conv : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'v</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp"><a href="#val-exp" class="anchor"></a><code><span><span class="keyword">val</span> exp : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, int, <span class="type-var">'b</span>, <span class="type-var">'c</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_var_subst"><a href="#val-exp_var_subst" class="anchor"></a><code><span><span class="keyword">val</span> exp_var_subst : 
+  <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span></span></code></div><div class="spec-doc"><p>Convert an expression from isla to Ast but using a var-to-exp conversion function</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_add_type_var_subst"><a href="#val-exp_add_type_var_subst" class="anchor"></a><code><span><span class="keyword">val</span> exp_add_type_var_subst : 
+  <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div><div class="spec-doc"><p>Convert directly from an untyped isla expression to an <a href="../../Exp/Typed/index.html"><code>Exp.Typed</code></a> by substituing isla variables with already typed expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smt_var_conv"><a href="#val-smt_var_conv" class="anchor"></a><code><span><span class="keyword">val</span> smt_var_conv : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'v</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'v</span>, <span class="type-var">'b</span>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-smt">Ast.smt</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smt"><a href="#val-smt" class="anchor"></a><code><span><span class="keyword">val</span> smt : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, int, <span class="type-var">'b</span>, <span class="type-var">'c</span>)</span> <a href="../../Ast/index.html#type-smt">Ast.smt</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Manip/index.html b/doc/html/read-dwarf/Isla/Manip/index.html
index ba186bcc..3c046128 100644
--- a/doc/html/read-dwarf/Isla/Manip/index.html
+++ b/doc/html/read-dwarf/Isla/Manip/index.html
@@ -1,2 +1,22 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Manip (read-dwarf.Isla.Manip)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Manip</nav><h1>Module <code>Isla.Manip</code></h1><p>This module provide generic manipulation function of isla ast</p><nav class="toc"><ul><li><a href="#trace-properties">Trace Properties</a></li><li><a href="#get-annotations">Get annotations</a></li><li><a href="#non-recursive-maps-and-iters">Non-recursive maps and iters</a></li><li><a href="#recursive-maps-and-iters">Recursive maps and iters</a></li><li><a href="#variable-substitution">Variable substitution</a></li><li><a href="#accessor-list-conversion">Accessor list conversion</a></li><li><a href="#valu-string-path-access">Valu string path access</a></li><li><a href="#trace-filtering">Trace Filtering</a></li></ul></nav></header><section><header><h2 id="trace-properties"><a href="#trace-properties" class="anchor"></a>Trace Properties</h2></header><dl><dt class="spec value" id="val-is_linear"><a href="#val-is_linear" class="anchor"></a><code><span class="keyword">val</span> is_linear : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if a trace is linear (has no branches)</p></dd></dl></section><section><header><h2 id="get-annotations"><a href="#get-annotations" class="anchor"></a>Get annotations</h2></header><dl><dt class="spec value" id="val-annot_exp"><a href="#val-annot_exp" class="anchor"></a><code><span class="keyword">val</span> annot_exp : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the annotation of an expression</p></dd></dl><dl><dt class="spec value" id="val-annot_event"><a href="#val-annot_event" class="anchor"></a><code><span class="keyword">val</span> annot_event : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the annotation of an event</p></dd></dl></section><section><header><h2 id="non-recursive-maps-and-iters"><a href="#non-recursive-maps-and-iters" class="anchor"></a>Non-recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>direct_a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively. Then a new a with the same structure is formed.</p><p><code>direct_a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively.</p></header><dl><dt class="spec value" id="val-direct_exp_map_exp"><a href="#val-direct_exp_map_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_map_exp : <span>(<span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span></code></dt><dt class="spec value" id="val-direct_exp_iter_exp"><a href="#val-direct_exp_iter_exp" class="anchor"></a><code><span class="keyword">val</span> direct_exp_iter_exp : <span>(<span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-direct_smt_map_exp"><a href="#val-direct_smt_map_exp" class="anchor"></a><code><span class="keyword">val</span> direct_smt_map_exp : <span>(<span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.smt</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.smt</span></code></dt><dt class="spec value" id="val-direct_event_map_exp"><a href="#val-direct_event_map_exp" class="anchor"></a><code><span class="keyword">val</span> direct_event_map_exp : <span>(<span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span></code></dt><dt class="spec value" id="val-direct_event_iter_valu"><a href="#val-direct_event_iter_valu" class="anchor"></a><code><span class="keyword">val</span> direct_event_iter_valu : <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-direct_event_map_valu"><a href="#val-direct_event_map_valu" class="anchor"></a><code><span class="keyword">val</span> direct_event_map_valu : <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span></code></dt><dt class="spec value" id="val-direct_valu_iter_valu"><a href="#val-direct_valu_iter_valu" class="anchor"></a><code><span class="keyword">val</span> direct_valu_iter_valu : <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-direct_valu_map_valu"><a href="#val-direct_valu_map_valu" class="anchor"></a><code><span class="keyword">val</span> direct_valu_map_valu : <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu)</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu</code></dt></dl></section><section><header><h2 id="recursive-maps-and-iters"><a href="#recursive-maps-and-iters" class="anchor"></a>Recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively on all b that appear directly or indirectly in a</p><p><code>a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively</p><p>Doing this when a = b is not well defined, and can be easily done using the direct version from previous section.</p><p>In case where a type is not recusive like <code>event</code>, both direct and recursive versions are the same.</p></header><dl><dt class="spec value" id="val-exp_iter_var"><a href="#val-exp_iter_var" class="anchor"></a><code><span class="keyword">val</span> exp_iter_var : <span>(int <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>iterate a function on all the variable of an expression</p></dd></dl><dl><dt class="spec value" id="val-event_iter_valu"><a href="#val-event_iter_valu" class="anchor"></a><code><span class="keyword">val</span> event_iter_valu : <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.event</span> <span>&#45;&gt;</span> unit</code></dt></dl></section><section><header><h2 id="variable-substitution"><a href="#variable-substitution" class="anchor"></a>Variable substitution</h2></header><dl><dt class="spec value" id="val-var_subst"><a href="#val-var_subst" class="anchor"></a><code><span class="keyword">val</span> var_subst : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span></code></dt><dd><p>Substitute variable with expression according to subst function</p></dd></dl></section><section><header><h2 id="accessor-list-conversion"><a href="#accessor-list-conversion" class="anchor"></a>Accessor list conversion</h2></header><dl><dt class="spec value" id="val-accessor_of_string"><a href="#val-accessor_of_string" class="anchor"></a><code><span class="keyword">val</span> accessor_of_string : string <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.accessor</code></dt><dt class="spec value" id="val-string_of_accessor"><a href="#val-string_of_accessor" class="anchor"></a><code><span class="keyword">val</span> string_of_accessor : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.accessor <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-accessor_of_string_list"><a href="#val-accessor_of_string_list" class="anchor"></a><code><span class="keyword">val</span> accessor_of_string_list : <span>string list</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.accessor_list</code></dt><dt class="spec value" id="val-string_of_accessor_list"><a href="#val-string_of_accessor_list" class="anchor"></a><code><span class="keyword">val</span> string_of_accessor_list : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.accessor_list <span>&#45;&gt;</span> <span>string list</span></code></dt></dl></section><section><header><h2 id="valu-string-path-access"><a href="#valu-string-path-access" class="anchor"></a>Valu string path access</h2></header><dl><dt class="spec value" id="val-valu_get"><a href="#val-valu_get" class="anchor"></a><code><span class="keyword">val</span> valu_get : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <span>string list</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu</code></dt><dd><p>Follow the path in a value like A.B.C in (struct (|B| (struct (|C| ...))))</p></dd></dl></section><section><header><h2 id="trace-filtering"><a href="#trace-filtering" class="anchor"></a>Trace Filtering</h2><p>This is some basic trace filtering that remove unwanted item from the trace in various situations</p></header><dl><dt class="spec value" id="val-split_cycle"><a href="#val-split_cycle" class="anchor"></a><code><span class="keyword">val</span> split_cycle : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span> * <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span></code></dt><dd><p>Split the trace between before and after the &quot;cycle&quot; event</p></dd></dl><dl><dt class="spec value" id="val-remove_init"><a href="#val-remove_init" class="anchor"></a><code><span class="keyword">val</span> remove_init : <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span></code></dt><dd><p>Remove all events before the &quot;cycle&quot; event, keep the SMT statements</p></dd></dl><dl><dt class="spec value" id="val-remove_ignored"><a href="#val-remove_ignored" class="anchor"></a><code><span class="keyword">val</span> remove_ignored : <span><a href="../../Utils/index.html#module-String">Utils.String</a>.t <a href="../../Utils/index.html#module-List">Utils.List</a>.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.trc</span></code></dt><dd><p>Remove all the events related to ignored registers</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Manip (read-dwarf.Isla.Manip)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Manip</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Manip</span></code></h1><p>This module provide generic manipulation function of isla ast</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#trace-properties">Trace Properties</a></li><li><a href="#get-annotations">Get annotations</a></li><li><a href="#non-recursive-maps-and-iters">Non-recursive maps and iters</a></li><li><a href="#recursive-maps-and-iters">Recursive maps and iters</a></li><li><a href="#variable-substitution">Variable substitution</a></li><li><a href="#accessor-list-conversion">Accessor list conversion</a></li><li><a href="#valu-string-path-access">Valu string path access</a></li><li><a href="#trace-filtering">Trace Filtering</a></li></ul></nav></div><div class="odoc-content"><h2 id="trace-properties"><a href="#trace-properties" class="anchor"></a>Trace Properties</h2><div class="odoc-spec"><div class="spec value anchored" id="val-is_linear"><a href="#val-is_linear" class="anchor"></a><code><span><span class="keyword">val</span> is_linear : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if a trace is linear (has no branches)</p></div></div><h2 id="get-annotations"><a href="#get-annotations" class="anchor"></a>Get annotations</h2><div class="odoc-spec"><div class="spec value anchored" id="val-annot_exp"><a href="#val-annot_exp" class="anchor"></a><code><span><span class="keyword">val</span> annot_exp : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the annotation of an expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-annot_event"><a href="#val-annot_event" class="anchor"></a><code><span><span class="keyword">val</span> annot_event : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the annotation of an event</p></div></div><h2 id="non-recursive-maps-and-iters"><a href="#non-recursive-maps-and-iters" class="anchor"></a>Non-recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>direct_a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively. Then a new a with the same structure is formed.</p><p><code>direct_a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all <code>b</code> in <code>a</code>, non-recursively.</p><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_map_exp"><a href="#val-direct_exp_map_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_map_exp : 
+  <span><span>(<span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_exp_iter_exp"><a href="#val-direct_exp_iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_exp_iter_exp : <span><span>(<span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_smt_map_exp"><a href="#val-direct_smt_map_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_smt_map_exp : 
+  <span><span>(<span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-smt">Base.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <a href="../Base/index.html#type-smt">Base.smt</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_event_map_exp"><a href="#val-direct_event_map_exp" class="anchor"></a><code><span><span class="keyword">val</span> direct_event_map_exp : 
+  <span><span>(<span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_event_iter_valu"><a href="#val-direct_event_iter_valu" class="anchor"></a><code><span><span class="keyword">val</span> direct_event_iter_valu : <span><span>(<span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_event_map_valu"><a href="#val-direct_event_map_valu" class="anchor"></a><code><span><span class="keyword">val</span> direct_event_map_valu : 
+  <span><span>(<span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-valu">Base.valu</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_valu_iter_valu"><a href="#val-direct_valu_iter_valu" class="anchor"></a><code><span><span class="keyword">val</span> direct_valu_iter_valu : <span><span>(<span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct_valu_map_valu"><a href="#val-direct_valu_map_valu" class="anchor"></a><code><span><span class="keyword">val</span> direct_valu_map_valu : <span><span>(<span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-valu">Base.valu</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-valu">Base.valu</a></span></code></div></div><h2 id="recursive-maps-and-iters"><a href="#recursive-maps-and-iters" class="anchor"></a>Recursive maps and iters</h2><p>This section is filled on demand.</p><p><code>a_map_b</code> take a function <code>b -&gt; b</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively on all b that appear directly or indirectly in a</p><p><code>a_iter_b</code> take a function <code>b -&gt; unit</code> and applies it to all the <code>b</code> in <code>a</code>, and do that recursively</p><p>Doing this when a = b is not well defined, and can be easily done using the direct version from previous section.</p><p>In case where a type is not recusive like <code>event</code>, both direct and recursive versions are the same.</p><div class="odoc-spec"><div class="spec value anchored" id="val-exp_iter_var"><a href="#val-exp_iter_var" class="anchor"></a><code><span><span class="keyword">val</span> exp_iter_var : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>iterate a function on all the variable of an expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-event_iter_valu"><a href="#val-event_iter_valu" class="anchor"></a><code><span><span class="keyword">val</span> event_iter_valu : <span><span>(<span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-event">Base.event</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_valu_path"><a href="#val-iter_valu_path" class="anchor"></a><code><span><span class="keyword">val</span> iter_valu_path : 
+  <span><span>(<span><span>string list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Iterate a function over a <code>valu</code> broken up into fields, extending the given path.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_valu_path"><a href="#val-map_valu_path" class="anchor"></a><code><span><span class="keyword">val</span> map_valu_path : 
+  <span><span>(<span><span>string list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Map a function over a <code>valu</code> broken up into fields, extending the given path.</p></div></div><h2 id="variable-substitution"><a href="#variable-substitution" class="anchor"></a>Variable substitution</h2><div class="odoc-spec"><div class="spec value anchored" id="val-var_subst"><a href="#val-var_subst" class="anchor"></a><code><span><span class="keyword">val</span> var_subst : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-exp">Base.exp</a></span></span></code></div><div class="spec-doc"><p>Substitute variable with expression according to subst function</p></div></div><h2 id="accessor-list-conversion"><a href="#accessor-list-conversion" class="anchor"></a>Accessor list conversion</h2><div class="odoc-spec"><div class="spec value anchored" id="val-accessor_of_string"><a href="#val-accessor_of_string" class="anchor"></a><code><span><span class="keyword">val</span> accessor_of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-accessor">Base.accessor</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_of_accessor"><a href="#val-string_of_accessor" class="anchor"></a><code><span><span class="keyword">val</span> string_of_accessor : <span><a href="../Base/index.html#type-accessor">Base.accessor</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-accessor_of_string_list"><a href="#val-accessor_of_string_list" class="anchor"></a><code><span><span class="keyword">val</span> accessor_of_string_list : <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-accessor_list">Base.accessor_list</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_of_accessor_list"><a href="#val-string_of_accessor_list" class="anchor"></a><code><span><span class="keyword">val</span> string_of_accessor_list : <span><a href="../Base/index.html#type-accessor_list">Base.accessor_list</a> <span class="arrow">&#45;&gt;</span></span> <span>string list</span></span></code></div></div><h2 id="valu-string-path-access"><a href="#valu-string-path-access" class="anchor"></a>Valu string path access</h2><div class="odoc-spec"><div class="spec value anchored" id="val-valu_get"><a href="#val-valu_get" class="anchor"></a><code><span><span class="keyword">val</span> valu_get : <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-valu">Base.valu</a></span></code></div><div class="spec-doc"><p>Follow the path in a value like A.B.C in (struct (|B| (struct (|C| ...))))</p></div></div><h2 id="trace-filtering"><a href="#trace-filtering" class="anchor"></a>Trace Filtering</h2><p>This is some basic trace filtering that remove unwanted item from the trace in various situations</p><div class="odoc-spec"><div class="spec value anchored" id="val-split_cycle"><a href="#val-split_cycle" class="anchor"></a><code><span><span class="keyword">val</span> split_cycle : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span> * <span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span></span></code></div><div class="spec-doc"><p>Split the trace between before and after the &quot;cycle&quot; event</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_init"><a href="#val-remove_init" class="anchor"></a><code><span><span class="keyword">val</span> remove_init : <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span></span></code></div><div class="spec-doc"><p>Remove all events before the &quot;cycle&quot; event, keep the SMT statements</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_ignored"><a href="#val-remove_ignored" class="anchor"></a><code><span><span class="keyword">val</span> remove_ignored : <span><span><a href="../../Utils/String/index.html#type-t">Utils.String.t</a> <a href="../../Utils/List/index.html#type-t">Utils.List.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Base/index.html#type-trc">Base.trc</a></span></span></code></div><div class="spec-doc"><p>Remove all the events related to ignored registers</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Preprocess/index.html b/doc/html/read-dwarf/Isla/Preprocess/index.html
index 3b6c43a8..d3a41b76 100644
--- a/doc/html/read-dwarf/Isla/Preprocess/index.html
+++ b/doc/html/read-dwarf/Isla/Preprocess/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Preprocess (read-dwarf.Isla.Preprocess)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Preprocess</nav><h1>Module <code>Isla.Preprocess</code></h1><p>This module is about preprocessing isla traces. This includes:</p><ul><li>Removing exceptional traces</li><li>Removing useless operation and simplifying</li><li>Removing all effect of initialization before cycle</li><li>Splitting branches that are non exceptional the right way</li></ul><p>This is important because isla print everything the sail code does, but, as the sail code is not written for performance, it will often do a lot of computation and then later decide it wasn't useful and discard the result. This quickly make isla traces bloated.</p><p>Once preprocessed, there is only a simple list of traces.</p><ul><li>Special instructions like smc have zero traces and must be provided with special semantics</li><li>Normal instructions have one traces (all exceptional cases are classified as UB)</li><li>Branching instruction have more than one traces.</li></ul><p>For example at time of writing, a basic load like <code>ldr x0, [x1]</code> has about 1300 variable before preprocessing and 27 after.</p><p>TODO: Remove useless register reads (Need a model where reading register has no side effect).</p></header><dl><dt class="spec value" id="val-simplify_trc"><a href="#val-simplify_trc" class="anchor"></a><code><span class="keyword">val</span> simplify_trc : <a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a></code></dt><dd><p>Simplify a simple trace by removing all useless variables</p></dd></dl><dl><dt class="spec value" id="val-preprocess"><a href="#val-preprocess" class="anchor"></a><code><span class="keyword">val</span> preprocess : <a href="../Server/index.html#type-config">Server.config</a> <span>&#45;&gt;</span> <a href="../Server/index.html#type-trcs">Server.trcs</a> <span>&#45;&gt;</span> <span><a href="../Base/index.html#type-rtrc">Base.rtrc</a> list</span></code></dt><dd><p>Preprocess a group of traces, by removing useless registers (according to the config), removing initialisation code and simplifying with <a href="index.html#val-simplify_trc"><code>simplify_trc</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Preprocess (read-dwarf.Isla.Preprocess)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Preprocess</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Preprocess</span></code></h1><p>This module is about preprocessing isla traces. This includes:</p><ul><li>Removing exceptional traces</li><li>Removing useless operation and simplifying</li><li>Removing all effect of initialization before cycle</li><li>Splitting branches that are non exceptional the right way</li></ul><p>This is important because isla print everything the sail code does, but, as the sail code is not written for performance, it will often do a lot of computation and then later decide it wasn't useful and discard the result. This quickly make isla traces bloated.</p><p>Once preprocessed, there is only a simple list of traces.</p><ul><li>Special instructions like smc have zero traces and must be provided with special semantics</li><li>Normal instructions have one traces (all exceptional cases are classified as UB)</li><li>Branching instruction have more than one traces.</li></ul><p>For example at time of writing, a basic load like <code>ldr x0, [x1]</code> has about 1300 variable before preprocessing and 27 after.</p><p>TODO: Remove useless register reads (Need a model where reading register has no side effect).</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_trc"><a href="#val-simplify_trc" class="anchor"></a><code><span><span class="keyword">val</span> simplify_trc : <span><span class="optlabel">?num_segments</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a></span></code></div><div class="spec-doc"><p>Simplify a simple trace by removing all useless variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-preprocess"><a href="#val-preprocess" class="anchor"></a><code><span><span class="keyword">val</span> preprocess : <span><a href="../Server/index.html#type-config">Server.config</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Server/index.html#type-trcs">Server.trcs</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-rtrcs">Base.rtrcs</a></span></code></div><div class="spec-doc"><p>Preprocess a group of traces, by removing useless registers (according to the config), removing initialisation code and simplifying with <a href="#val-simplify_trc"><code>simplify_trc</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Run/index.html b/doc/html/read-dwarf/Isla/Run/index.html
index b172cb58..2b3762cf 100644
--- a/doc/html/read-dwarf/Isla/Run/index.html
+++ b/doc/html/read-dwarf/Isla/Run/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Run (read-dwarf.Isla.Run)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Run</nav><h1>Module <code>Isla.Run</code></h1><p>This module provide facility to run <a href="../index.html"><code>Isla</code></a> trace over <a href="../../State/index.html"><span>states</span></a></p><p>The main functions are <a href="index.html#val-trc"><code>trc</code></a> for pure interface and <a href="index.html#val-trc_mut"><code>trc_mut</code></a> for imperative interface.</p><p><a href="index.html#exception-RunError"><code>RunError</code></a> will be thrown when something goes wrong.</p><p>It is for testing purpose only, otherwise use <a href="../../Trace/Run/index.html"><code>Trace.Run</code></a>. Typing does not work, and some other expected behavior may not work either.</p><p>This module can be considered deprecated/legacy.</p></header><dl><dt class="spec exception" id="exception-RunError"><a href="#exception-RunError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">RunError</span> <span class="keyword">of</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * string</code></dt><dd><p>Exception that represent an Isla runtime error which should not happen</p></dd></dl><dl><dt class="spec value" id="val-run_error"><a href="#val-run_error" class="anchor"></a><code><span class="keyword">val</span> run_error : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Throw a run error with the string part as formated by the format string</p></dd></dl><dl><dt class="spec type" id="type-value_context"><a href="#type-value_context" class="anchor"></a><code><span class="keyword">type</span> value_context</code><code> = <span><a href="../../State/index.html#type-exp">State.exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></code></dt><dd><p>The contex of value that associate isla variable numbers to state expression</p></dd></dl><dl><dt class="spec value" id="val-get_var"><a href="#val-get_var" class="anchor"></a><code><span class="keyword">val</span> get_var : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <span><a href="../../State__Base/Exp/index.html#type-t">State.Exp.t</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../../State__Base/Exp/index.html#type-t">State.Exp.t</a></code></dt><dd><p>Get the expression associated to the free variable. Throw <a href="index.html#exception-RunError"><code>RunError</code></a>, if the variable is no bound. The <a href="../index.html#type-lrng"><code>lrng</code></a> is for error reporting.</p></dd></dl><dl><dt class="spec value" id="val-exp_conv_subst"><a href="#val-exp_conv_subst" class="anchor"></a><code><span class="keyword">val</span> exp_conv_subst : <a href="index.html#type-value_context">value_context</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-rexp">Base.rexp</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-exp">State.exp</a></code></dt><dd><p>Convert an <a href="../index.html"><code>Isla</code></a> expression to an <a href="../../Ast/index.html"><code>Ast</code></a> by substituing all free variable with the bound expression in the <a href="index.html#type-value_context"><code>value_context</code></a>.</p><p>If a variable is not bound, throw <a href="index.html#exception-RunError"><code>RunError</code></a></p></dd></dl><dl><dt class="spec value" id="val-exp_of_valu"><a href="#val-exp_of_valu" class="anchor"></a><code><span class="keyword">val</span> exp_of_valu : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <span><a href="../../State__Base/Exp/index.html#type-t">State.Exp.t</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <a href="../../State/index.html#type-exp">State.exp</a></code></dt><dd><p>Give the <a href="../../State/index.html#type-exp"><code>State.exp</code></a> that represents the input <a href="../index.html#type-valu"><code>valu</code></a>.</p><p>A symbolic variable i is represented by the expression bound to it in the provided <a href="index.html#type-value_context"><code>value_context</code></a>.</p><p>Newly created expression are located with the provided <a href="../index.html#type-lrng"><code>lrng</code></a>.</p><p>If the value is not convertible to a state expression, throw a <a href="index.html#exception-RunError"><code>RunError</code></a></p></dd></dl><dl><dt class="spec value" id="val-write_to_var"><a href="#val-write_to_var" class="anchor"></a><code><span class="keyword">val</span> write_to_var : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>This function write an expression to symbolic variable. The write is ignored if the variable was already set because isla guarantee that it would be the same value (Trusting Isla here)</p></dd></dl><dl><dt class="spec value" id="val-write_to_valu"><a href="#val-write_to_valu" class="anchor"></a><code><span class="keyword">val</span> write_to_valu : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>This function write an expression to an <a href="../index.html#type-valu"><code>valu</code></a>.</p><p>If the valu is a variable, it is added to the context, otherwise nothing happens.</p></dd></dl><dl><dt class="spec value" id="val-event_mut"><a href="#val-event_mut" class="anchor"></a><code><span class="keyword">val</span> event_mut : <a href="index.html#type-value_context">value_context</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-revent">Base.revent</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Run an event on <a href="../../State/index.html#type-t"><code>State.t</code></a> and a <a href="index.html#type-value_context"><code>value_context</code></a> by mutating both</p></dd></dl><dl><dt class="spec value" id="val-trc_mut"><a href="#val-trc_mut" class="anchor"></a><code><span class="keyword">val</span> trc_mut : <span>?&#8288;vc:<span><a href="../../State/index.html#type-exp">State.exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>This function run an isla trace on a state by mutation. If a <code>vc</code> is provided, then it is used and mutated according to the trace.</p><p>Any encountered branch are ignored and their assertion are added to the state</p></dd></dl><dl><dt class="spec value" id="val-trc"><a href="#val-trc" class="anchor"></a><code><span class="keyword">val</span> trc : <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a></code></dt><dd><p>This function run an isla trace on a state and return the end state as a new state</p><p>It is just a wrapper of <code>run_trc_mut</code> that remove the imperative interface The new state is fresh and locked.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Run (read-dwarf.Isla.Run)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Run</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Run</span></code></h1><p>This module provide facility to run <a href="../index.html"><code>Isla</code></a> trace over <a href="../../State/index.html" title="State">states</a></p><p>The main functions are <a href="#val-trc"><code>trc</code></a> for pure interface and <a href="#val-trc_mut"><code>trc_mut</code></a> for imperative interface.</p><p><a href="#exception-RunError"><code>RunError</code></a> will be thrown when something goes wrong.</p><p>It is for testing purpose only, otherwise use <a href="../../Trace/Run/index.html"><code>Trace.Run</code></a>. Typing does not work, and some other expected behavior may not work either.</p><p>This module can be considered deprecated/legacy.</p><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> Should not be used by new modules</li></ul></header><div class="odoc-content"><div class="odoc-spec"><div class="spec exception anchored" id="exception-RunError"><a href="#exception-RunError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">RunError</span> <span class="keyword">of</span> <a href="../Base/index.html#type-lrng">Base.lrng</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla runtime error which should not happen</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run_error"><a href="#val-run_error" class="anchor"></a><code><span><span class="keyword">val</span> run_error : <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Throw a run error with the string part as formated by the format string</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value_context"><a href="#type-value_context" class="anchor"></a><code><span><span class="keyword">type</span> value_context</span><span> = <span><a href="../../State/index.html#type-exp">State.exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span></code></div><div class="spec-doc"><p>The contex of value that associate isla variable numbers to state expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_var"><a href="#val-get_var" class="anchor"></a><code><span><span class="keyword">val</span> get_var : <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="../../State/Base/Exp/index.html#type-t">State.Exp.t</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../../State/Base/Exp/index.html#type-t">State.Exp.t</a></span></code></div><div class="spec-doc"><p>Get the expression associated to the free variable. Throw <a href="#exception-RunError"><code>RunError</code></a>, if the variable is no bound. The <a href="../index.html#type-lrng"><code>lrng</code></a> is for error reporting.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_conv_subst"><a href="#val-exp_conv_subst" class="anchor"></a><code><span><span class="keyword">val</span> exp_conv_subst : <span><a href="#type-value_context">value_context</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-rexp">Base.rexp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-exp">State.exp</a></span></code></div><div class="spec-doc"><p>Convert an <a href="../index.html"><code>Isla</code></a> expression to an <a href="../../Ast/index.html"><code>Ast</code></a> by substituing all free variable with the bound expression in the <a href="#type-value_context"><code>value_context</code></a>.</p><p>If a variable is not bound, throw <a href="#exception-RunError"><code>RunError</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_of_valu"><a href="#val-exp_of_valu" class="anchor"></a><code><span><span class="keyword">val</span> exp_of_valu : 
+  <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="../../State/Base/Exp/index.html#type-t">State.Exp.t</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../State/index.html#type-exp">State.exp</a></span></code></div><div class="spec-doc"><p>Give the <a href="../../State/index.html#type-exp"><code>State.exp</code></a> that represents the input <a href="../index.html#type-valu"><code>valu</code></a>.</p><p>A symbolic variable i is represented by the expression bound to it in the provided <a href="#type-value_context"><code>value_context</code></a>.</p><p>Newly created expression are located with the provided <a href="../index.html#type-lrng"><code>lrng</code></a>.</p><p>If the value is not convertible to a state expression, throw a <a href="#exception-RunError"><code>RunError</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_to_var"><a href="#val-write_to_var" class="anchor"></a><code><span><span class="keyword">val</span> write_to_var : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>This function write an expression to symbolic variable. The write is ignored if the variable was already set because isla guarantee that it would be the same value (Trusting Isla here)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_to_valu"><a href="#val-write_to_valu" class="anchor"></a><code><span><span class="keyword">val</span> write_to_valu : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>This function write an expression to an <a href="../index.html#type-valu"><code>valu</code></a>.</p><p>If the valu is a variable, it is added to the context, otherwise nothing happens.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-event_mut"><a href="#val-event_mut" class="anchor"></a><code><span><span class="keyword">val</span> event_mut : <span><a href="#type-value_context">value_context</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-revent">Base.revent</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Run an event on <a href="../../State/index.html#type-t"><code>State.t</code></a> and a <a href="#type-value_context"><code>value_context</code></a> by mutating both</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trc_mut"><a href="#val-trc_mut" class="anchor"></a><code><span><span class="keyword">val</span> trc_mut : <span><span class="optlabel">?vc</span>:<span><a href="../../State/index.html#type-exp">State.exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>This function run an isla trace on a state by mutation. If a <code>vc</code> is provided, then it is used and mutated according to the trace.</p><p>Any encountered branch are ignored and their assertion are added to the state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trc"><a href="#val-trc" class="anchor"></a><code><span><span class="keyword">val</span> trc : <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-t">State.t</a></span></code></div><div class="spec-doc"><p>This function run an isla trace on a state and return the end state as a new state</p><p>It is just a wrapper of <code>run_trc_mut</code> that remove the imperative interface The new state is fresh and locked.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Server/Cmd/index.html b/doc/html/read-dwarf/Isla/Server/Cmd/index.html
index b7394571..fd41a30f 100644
--- a/doc/html/read-dwarf/Isla/Server/Cmd/index.html
+++ b/doc/html/read-dwarf/Isla/Server/Cmd/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cmd (read-dwarf.Isla.Server.Cmd)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Server</a> &#x00BB; Cmd</nav><h1>Module <code>Server.Cmd</code></h1><p>This module provide a CLI subcommand to test isla directly. All isla output is reported as raw text</p></header><dl><dt class="spec value" id="val-server_test"><a href="#val-server_test" class="anchor"></a><code><span class="keyword">val</span> server_test : <a href="../../../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cmd (read-dwarf.Isla.Server.Cmd)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Isla</a> &#x00BB; <a href="../index.html">Server</a> &#x00BB; Cmd</nav><header class="odoc-preamble"><h1>Module <code><span>Server.Cmd</span></code></h1><p>This module provide a CLI subcommand to test isla directly. All isla output is reported as raw text</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-server_test"><a href="#val-server_test" class="anchor"></a><code><span><span class="keyword">val</span> server_test : <span><a href="../../../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Server/index.html b/doc/html/read-dwarf/Isla/Server/index.html
index c3939ef7..a3ffb766 100644
--- a/doc/html/read-dwarf/Isla/Server/index.html
+++ b/doc/html/read-dwarf/Isla/Server/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Server (read-dwarf.Isla.Server)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Server</nav><h1>Module <code>Isla.Server</code></h1><p>This module is about launching isla as a background server and using it</p><p>Important remark: even if I call isla a server because in a logical sense read-dwarf is making request to isla and isla is serving them, in Unix sense read-dwarf is the server because it listen to the socket and isla connect to it.</p></header><div class="spec module" id="module-ConfigFile"><a href="#module-ConfigFile" class="anchor"></a><code><span class="keyword">module</span> ConfigFile = <a href="../../Config/index.html#module-File">Config.File</a></code></div><div class="spec module" id="module-CommonOpt"><a href="#module-CommonOpt" class="anchor"></a><code><span class="keyword">module</span> CommonOpt = <a href="../../Config/index.html#module-CommonOpt">Config.CommonOpt</a></code></div><div class="spec module" id="module-Config"><a href="#module-Config" class="anchor"></a><code><span class="keyword">module</span> <a href="Config/index.html">Config</a> = <a href="../../Config__File/ArchConf/index.html#module-Isla">Config.File.ArchConf.Isla</a></code></div><div class="spec module" id="module-Server"><a href="#module-Server" class="anchor"></a><code><span class="keyword">module</span> Server = <a href="../../Utils/Cmd/index.html#module-SocketServer">Utils.Cmd.SocketServer</a></code></div><dl><dt class="spec type" id="type-config"><a href="#type-config" class="anchor"></a><code><span class="keyword">type</span> config</code><code> = <a href="../../Config__File/ArchConf/Isla/index.html#type-t">Config.t</a></code></dt><dd><p>The configuration record type</p></dd></dl><dl><dt class="spec type" id="type-trcs"><a href="#type-trcs" class="anchor"></a><code><span class="keyword">type</span> trcs</code><code> = <span><span>(bool * <a href="../Base/index.html#type-rtrc">Base.rtrc</a>)</span> list</span></code></dt><dd><p>The raw output of the server for an instruction.</p><p>It is a list of traces, each with a flag telling if they are normal traces (no processor exception/fault) or not</p></dd></dl><dl><dt class="spec value" id="val-required_version"><a href="#val-required_version" class="anchor"></a><code><span class="keyword">val</span> required_version : string</code></dt><dd><p>Bump when updating isla. TODO: move the version checking to allow a range of version. Also, right now the cache invalidation is based on this and not on the actual isla version, which may be dangerous.</p></dd></dl><dl><dt class="spec value" id="val-req_num"><a href="#val-req_num" class="anchor"></a><code><span class="keyword">val</span> req_num : <span>int Stdlib.ref</span></code></dt><dt class="spec value" id="val-server"><a href="#val-server" class="anchor"></a><code><span class="keyword">val</span> server : <span><span><a href="../../Utils__Cmd/SocketServer/index.html#type-t">Server.t</a> option</span> Stdlib.ref</span></code></dt><dd><p>This instance of socket server for isla</p></dd></dl><dl><dt class="spec value" id="val-get_server"><a href="#val-get_server" class="anchor"></a><code><span class="keyword">val</span> get_server : unit <span>&#45;&gt;</span> <a href="../../Utils__Cmd/SocketServer/index.html#type-t">Server.t</a></code></dt><dd><p>Assume the server is started and get it out of the reference</p></dd></dl><dl><dt class="spec value" id="val-cmd_of_config"><a href="#val-cmd_of_config" class="anchor"></a><code><span class="keyword">val</span> cmd_of_config : <a href="index.html#type-config">config</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>string array</span></code></dt><dd><p>Compute the isla-client command line from the isla configuration</p></dd></dl><dl><dt class="spec value" id="val-raw_start"><a href="#val-raw_start" class="anchor"></a><code><span class="keyword">val</span> raw_start : <a href="index.html#type-config">config</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Start the server with the specified architecture, do not attempt any checks</p></dd></dl><dl><dt class="spec value" id="val-raw_stop"><a href="#val-raw_stop" class="anchor"></a><code><span class="keyword">val</span> raw_stop : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop the server by cutting the connection.</p></dd></dl><dl><dt class="spec type" id="type-basic_answer"><a href="#type-basic_answer" class="anchor"></a><code><span class="keyword">type</span> basic_answer</code><code> = </code><table class="variant"><tr id="type-basic_answer.Error" class="anchored"><td class="def constructor"><a href="#type-basic_answer.Error" class="anchor"></a><code>| </code><code><span class="constructor">Error</span></code></td></tr><tr id="type-basic_answer.Version" class="anchored"><td class="def constructor"><a href="#type-basic_answer.Version" class="anchor"></a><code>| </code><code><span class="constructor">Version</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-basic_answer.StartTraces" class="anchored"><td class="def constructor"><a href="#type-basic_answer.StartTraces" class="anchor"></a><code>| </code><code><span class="constructor">StartTraces</span></code></td></tr><tr id="type-basic_answer.Trace" class="anchored"><td class="def constructor"><a href="#type-basic_answer.Trace" class="anchor"></a><code>| </code><code><span class="constructor">Trace</span> <span class="keyword">of</span> bool * string</code></td></tr><tr id="type-basic_answer.EndTraces" class="anchored"><td class="def constructor"><a href="#type-basic_answer.EndTraces" class="anchor"></a><code>| </code><code><span class="constructor">EndTraces</span></code></td></tr></table></dt><dd><p>This should match exactly with the Answer type in isla-client code</p></dd></dl><dl><dt class="spec value" id="val-read_basic_answer"><a href="#val-read_basic_answer" class="anchor"></a><code><span class="keyword">val</span> read_basic_answer : unit <span>&#45;&gt;</span> <a href="index.html#type-basic_answer">basic_answer</a></code></dt><dd><p>Read an answer from isla-client. This must match exactly <code>write_answer</code> in <code>client.rs</code> in <code>isla</code></p></dd></dl><dl><dt class="spec type" id="type-answer"><a href="#type-answer" class="anchor"></a><code><span class="keyword">type</span> answer</code><code> = </code><table class="variant"><tr id="type-answer.Version" class="anchored"><td class="def constructor"><a href="#type-answer.Version" class="anchor"></a><code>| </code><code><span class="constructor">Version</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-answer.Traces" class="anchored"><td class="def constructor"><a href="#type-answer.Traces" class="anchor"></a><code>| </code><code><span class="constructor">Traces</span> <span class="keyword">of</span> <span><span>(bool * string)</span> list</span></code></td></tr></table></dt><dd><p>The interpreted answer. If the protocol is followed, then one request lead to exactly one answer of that type</p></dd></dl><dl><dt class="spec value" id="val-expect_version"><a href="#val-expect_version" class="anchor"></a><code><span class="keyword">val</span> expect_version : <a href="index.html#type-answer">answer</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Expect a version answer and fails if it is not the case</p></dd></dl><dl><dt class="spec value" id="val-expect_traces"><a href="#val-expect_traces" class="anchor"></a><code><span class="keyword">val</span> expect_traces : <a href="index.html#type-answer">answer</a> <span>&#45;&gt;</span> <span><span>(bool * string)</span> list</span></code></dt><dd><p>Expect isla traces and fails if it is not the case</p></dd></dl><dl><dt class="spec value" id="val-expect_parsed_traces"><a href="#val-expect_parsed_traces" class="anchor"></a><code><span class="keyword">val</span> expect_parsed_traces : <a href="index.html#type-answer">answer</a> <span>&#45;&gt;</span> <a href="index.html#type-trcs">trcs</a></code></dt><dd><p>Expect isla traces and fails if it is not the case, additionally parse them</p></dd></dl><dl><dt class="spec exception" id="exception-IslaError"><a href="#exception-IslaError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">IslaError</span></code></dt><dd><p>When isla encounter a non fatal error with that specific request. This error is recoverable and the sever can accept other requests</p></dd></dl><dl><dt class="spec value" id="val-read_answer"><a href="#val-read_answer" class="anchor"></a><code><span class="keyword">val</span> read_answer : unit <span>&#45;&gt;</span> <a href="index.html#type-answer">answer</a></code></dt><dd><p>Read the answer from isla, block until full answer</p></dd></dl><dl><dt class="spec value" id="val-pp_answer"><a href="#val-pp_answer" class="anchor"></a><code><span class="keyword">val</span> pp_answer : <a href="index.html#type-answer">answer</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Answer pretty printer</p></dd></dl><dl><dt class="spec type" id="type-request"><a href="#type-request" class="anchor"></a><code><span class="keyword">type</span> request</code><code> = </code><table class="variant"><tr id="type-request.TEXT_ASM" class="anchored"><td class="def constructor"><a href="#type-request.TEXT_ASM" class="anchor"></a><code>| </code><code><span class="constructor">TEXT_ASM</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-request.ASM" class="anchored"><td class="def constructor"><a href="#type-request.ASM" class="anchor"></a><code>| </code><code><span class="constructor">ASM</span> <span class="keyword">of</span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></code></td></tr><tr id="type-request.VERSION" class="anchored"><td class="def constructor"><a href="#type-request.VERSION" class="anchor"></a><code>| </code><code><span class="constructor">VERSION</span></code></td></tr><tr id="type-request.STOP" class="anchored"><td class="def constructor"><a href="#type-request.STOP" class="anchor"></a><code>| </code><code><span class="constructor">STOP</span></code></td></tr></table></dt><dd><p>The type of a request to isla</p></dd></dl><dl><dt class="spec value" id="val-string_of_request"><a href="#val-string_of_request" class="anchor"></a><code><span class="keyword">val</span> string_of_request : <a href="index.html#type-request">request</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert a request into the string message expected by isla-client This should match the protocol</p></dd></dl><dl><dt class="spec value" id="val-send_string_request"><a href="#val-send_string_request" class="anchor"></a><code><span class="keyword">val</span> send_string_request : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Send a string request to the server, and do not wait for any answer</p></dd></dl><dl><dt class="spec value" id="val-string_request"><a href="#val-string_request" class="anchor"></a><code><span class="keyword">val</span> string_request : string <span>&#45;&gt;</span> <a href="index.html#type-answer">answer</a></code></dt><dd><p>Same as <a href="index.html#type-request"><code>request</code></a> but takes the request directly as a string</p></dd></dl><dl><dt class="spec value" id="val-request"><a href="#val-request" class="anchor"></a><code><span class="keyword">val</span> request : <a href="index.html#type-request">request</a> <span>&#45;&gt;</span> <a href="index.html#type-answer">answer</a></code></dt><dd><p>Send a request and wait for answer</p></dd></dl><dl><dt class="spec value" id="val-request_bin_parsed"><a href="#val-request_bin_parsed" class="anchor"></a><code><span class="keyword">val</span> request_bin_parsed : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <a href="index.html#type-trcs">trcs</a></code></dt><dd><p>Request the traces of a binary instruction and parse the result.</p><p>This is the main entry point of this module.</p></dd></dl><dl><dt class="spec value" id="val-send_request"><a href="#val-send_request" class="anchor"></a><code><span class="keyword">val</span> send_request : <a href="index.html#type-request">request</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Send a request without expecting any answer</p></dd></dl><dl><dt class="spec value" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span class="keyword">val</span> stop : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop isla client by sending a stop request</p></dd></dl><dl><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : <a href="index.html#type-config">config</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Start isla and check version</p></dd></dl><aside><p>Test that isla can start and keep a valid version</p></aside><dl><dt class="spec module" id="module-Cmd"><a href="#module-Cmd" class="anchor"></a><code><span class="keyword">module</span> <a href="Cmd/index.html">Cmd</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide a CLI subcommand to test isla directly. All isla output is reported as raw text</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Server (read-dwarf.Isla.Server)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Server</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Server</span></code></h1><p>This module is about launching isla as a background server and using it</p><p>Important remark: even if I call isla a server because in a logical sense read-dwarf is making request to isla and isla is serving them, in Unix sense read-dwarf is the server because it listen to the socket and isla connect to it.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-ConfigFile"><a href="#module-ConfigFile" class="anchor"></a><code><span><span class="keyword">module</span> ConfigFile</span><span> = <a href="../../Config/File/index.html">Config.File</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-CommonOpt"><a href="#module-CommonOpt" class="anchor"></a><code><span><span class="keyword">module</span> CommonOpt</span><span> = <a href="../../Config/CommonOpt/index.html">Config.CommonOpt</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Config"><a href="#module-Config" class="anchor"></a><code><span><span class="keyword">module</span> Config</span><span> = <a href="../../Config/File/ArchConf/Isla/index.html">Config.File.ArchConf.Isla</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Server"><a href="#module-Server" class="anchor"></a><code><span><span class="keyword">module</span> Server</span><span> = <a href="../../Utils/Cmd/SocketServer/index.html">Utils.Cmd.SocketServer</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-config"><a href="#type-config" class="anchor"></a><code><span><span class="keyword">type</span> config</span><span> = <a href="../../Config/File/ArchConf/Isla/index.html#type-t">Config.t</a></span></code></div><div class="spec-doc"><p>The configuration record type</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trcs"><a href="#type-trcs" class="anchor"></a><code><span><span class="keyword">type</span> trcs</span><span> = <span><a href="../Base/index.html#type-instruction_segments">Base.instruction_segments</a> option</span> * <span><span>(bool * <a href="../Base/index.html#type-rtrc">Base.rtrc</a>)</span> list</span></span></code></div><div class="spec-doc"><p>The raw output of the server for an instruction.</p><p>It is a list of traces, each with a flag telling if they are normal traces (no processor exception/fault) or not</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-opcode"><a href="#type-opcode" class="anchor"></a><code><span><span class="keyword">type</span> opcode</span><span> = <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span><a href="../Relocation/index.html#type-t">Relocation.t</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-required_version"><a href="#val-required_version" class="anchor"></a><code><span><span class="keyword">val</span> required_version : string</span></code></div><div class="spec-doc"><p>Bump when updating isla. TODO: move the version checking to allow a range of version. Also, right now the cache invalidation is based on this and not on the actual isla version, which may be dangerous.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-req_num"><a href="#val-req_num" class="anchor"></a><code><span><span class="keyword">val</span> req_num : <span>int <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-server"><a href="#val-server" class="anchor"></a><code><span><span class="keyword">val</span> server : <span><span><a href="../../Utils/Cmd/SocketServer/index.html#type-t">Server.t</a> option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>This instance of socket server for isla</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_server"><a href="#val-get_server" class="anchor"></a><code><span><span class="keyword">val</span> get_server : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Cmd/SocketServer/index.html#type-t">Server.t</a></span></code></div><div class="spec-doc"><p>Assume the server is started and get it out of the reference</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cmd_of_config"><a href="#val-cmd_of_config" class="anchor"></a><code><span><span class="keyword">val</span> cmd_of_config : <span><a href="#type-config">config</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span>string array</span></span></code></div><div class="spec-doc"><p>Compute the isla-client command line from the isla configuration</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-raw_start"><a href="#val-raw_start" class="anchor"></a><code><span><span class="keyword">val</span> raw_start : <span><a href="#type-config">config</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start the server with the specified architecture, do not attempt any checks</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-raw_stop"><a href="#val-raw_stop" class="anchor"></a><code><span><span class="keyword">val</span> raw_stop : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop the server by cutting the connection.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-basic_answer"><a href="#type-basic_answer" class="anchor"></a><code><span><span class="keyword">type</span> basic_answer</span><span> = </span></code><ol><li id="type-basic_answer.Error" class="def variant constructor anchored"><a href="#type-basic_answer.Error" class="anchor"></a><code><span>| </span><span><span class="constructor">Error</span></span></code></li><li id="type-basic_answer.Version" class="def variant constructor anchored"><a href="#type-basic_answer.Version" class="anchor"></a><code><span>| </span><span><span class="constructor">Version</span> <span class="keyword">of</span> string</span></code></li><li id="type-basic_answer.StartTraces" class="def variant constructor anchored"><a href="#type-basic_answer.StartTraces" class="anchor"></a><code><span>| </span><span><span class="constructor">StartTraces</span></span></code></li><li id="type-basic_answer.Trace" class="def variant constructor anchored"><a href="#type-basic_answer.Trace" class="anchor"></a><code><span>| </span><span><span class="constructor">Trace</span> <span class="keyword">of</span> bool * string</span></code></li><li id="type-basic_answer.EndTraces" class="def variant constructor anchored"><a href="#type-basic_answer.EndTraces" class="anchor"></a><code><span>| </span><span><span class="constructor">EndTraces</span></span></code></li><li id="type-basic_answer.Segments" class="def variant constructor anchored"><a href="#type-basic_answer.Segments" class="anchor"></a><code><span>| </span><span><span class="constructor">Segments</span> <span class="keyword">of</span> string</span></code></li></ol></div><div class="spec-doc"><p>This should match exactly with the Answer type in isla-client code</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_basic_answer"><a href="#val-read_basic_answer" class="anchor"></a><code><span><span class="keyword">val</span> read_basic_answer : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-basic_answer">basic_answer</a></span></code></div><div class="spec-doc"><p>Read an answer from isla-client. This must match exactly <code>write_answer</code> in <code>client.rs</code> in <code>isla</code></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-answer"><a href="#type-answer" class="anchor"></a><code><span><span class="keyword">type</span> answer</span><span> = </span></code><ol><li id="type-answer.Version" class="def variant constructor anchored"><a href="#type-answer.Version" class="anchor"></a><code><span>| </span><span><span class="constructor">Version</span> <span class="keyword">of</span> string</span></code></li><li id="type-answer.Traces" class="def variant constructor anchored"><a href="#type-answer.Traces" class="anchor"></a><code><span>| </span><span><span class="constructor">Traces</span> <span class="keyword">of</span> <span>string option</span> * <span><span>(bool * string)</span> list</span></span></code></li></ol></div><div class="spec-doc"><p>The interpreted answer. If the protocol is followed, then one request lead to exactly one answer of that type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_version"><a href="#val-expect_version" class="anchor"></a><code><span><span class="keyword">val</span> expect_version : <span><a href="#type-answer">answer</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Expect a version answer and fails if it is not the case</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_traces"><a href="#val-expect_traces" class="anchor"></a><code><span><span class="keyword">val</span> expect_traces : <span><a href="#type-answer">answer</a> <span class="arrow">&#45;&gt;</span></span> <span>string option</span> * <span><span>(bool * string)</span> list</span></span></code></div><div class="spec-doc"><p>Expect isla traces and fails if it is not the case</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_parsed_traces"><a href="#val-expect_parsed_traces" class="anchor"></a><code><span><span class="keyword">val</span> expect_parsed_traces : <span><a href="#type-answer">answer</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-trcs">trcs</a></span></code></div><div class="spec-doc"><p>Expect isla traces and fails if it is not the case, additionally parse them</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-IslaError"><a href="#exception-IslaError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">IslaError</span></span></code></div><div class="spec-doc"><p>When isla encounter a non fatal error with that specific request. This error is recoverable and the sever can accept other requests</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_answer"><a href="#val-read_answer" class="anchor"></a><code><span><span class="keyword">val</span> read_answer : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-answer">answer</a></span></code></div><div class="spec-doc"><p>Read the answer from isla, block until full answer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_answer"><a href="#val-pp_answer" class="anchor"></a><code><span><span class="keyword">val</span> pp_answer : <span><a href="#type-answer">answer</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Answer pretty printer</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-request"><a href="#type-request" class="anchor"></a><code><span><span class="keyword">type</span> request</span><span> = </span></code><ol><li id="type-request.TEXT_ASM" class="def variant constructor anchored"><a href="#type-request.TEXT_ASM" class="anchor"></a><code><span>| </span><span><span class="constructor">TEXT_ASM</span> <span class="keyword">of</span> string</span></code></li><li id="type-request.ASM" class="def variant constructor anchored"><a href="#type-request.ASM" class="anchor"></a><code><span>| </span><span><span class="constructor">ASM</span> <span class="keyword">of</span> <a href="#type-opcode">opcode</a></span></code></li><li id="type-request.VERSION" class="def variant constructor anchored"><a href="#type-request.VERSION" class="anchor"></a><code><span>| </span><span><span class="constructor">VERSION</span></span></code></li><li id="type-request.STOP" class="def variant constructor anchored"><a href="#type-request.STOP" class="anchor"></a><code><span>| </span><span><span class="constructor">STOP</span></span></code></li></ol></div><div class="spec-doc"><p>The type of a request to isla</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_of_request"><a href="#val-string_of_request" class="anchor"></a><code><span><span class="keyword">val</span> string_of_request : <span><a href="#type-request">request</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert a request into the string message expected by isla-client This should match the protocol</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_string_request"><a href="#val-send_string_request" class="anchor"></a><code><span><span class="keyword">val</span> send_string_request : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Send a string request to the server, and do not wait for any answer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_request"><a href="#val-string_request" class="anchor"></a><code><span><span class="keyword">val</span> string_request : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-answer">answer</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-request"><code>request</code></a> but takes the request directly as a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-request"><a href="#val-request" class="anchor"></a><code><span><span class="keyword">val</span> request : <span><a href="#type-request">request</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-answer">answer</a></span></code></div><div class="spec-doc"><p>Send a request and wait for answer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-request_bin_parsed"><a href="#val-request_bin_parsed" class="anchor"></a><code><span><span class="keyword">val</span> request_bin_parsed : <span><a href="#type-opcode">opcode</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-trcs">trcs</a></span></code></div><div class="spec-doc"><p>Request the traces of a binary instruction and parse the result.</p><p>This is the main entry point of this module.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_request"><a href="#val-send_request" class="anchor"></a><code><span><span class="keyword">val</span> send_request : <span><a href="#type-request">request</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Send a request without expecting any answer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span><span class="keyword">val</span> stop : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop isla client by sending a stop request</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span><a href="#type-config">config</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start isla and check version</p></div></div><p>Test that isla can start and keep a valid version</p><div class="odoc-spec"><div class="spec module anchored" id="module-Cmd"><a href="#module-Cmd" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cmd/index.html">Cmd</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a CLI subcommand to test isla directly. All isla output is reported as raw text</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Test/index.html b/doc/html/read-dwarf/Isla/Test/index.html
index 07fd6b68..4f23db37 100644
--- a/doc/html/read-dwarf/Isla/Test/index.html
+++ b/doc/html/read-dwarf/Isla/Test/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test (read-dwarf.Isla.Test)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Test</nav><h1>Module <code>Isla.Test</code></h1><p>This file about testing interaction with Isla for single instructions</p></header><div class="spec module" id="module-SMT"><a href="#module-SMT" class="anchor"></a><code><span class="keyword">module</span> SMT = <a href="../../Z3/index.html">Z3</a></code></div><dl><dt class="spec type" id="type-pmode"><a href="#type-pmode" class="anchor"></a><code><span class="keyword">type</span> pmode</code><code> = </code><table class="variant"><tr id="type-pmode.DUMP" class="anchored"><td class="def constructor"><a href="#type-pmode.DUMP" class="anchor"></a><code>| </code><code><span class="constructor">DUMP</span></code></td><td class="doc"><p>Dump isla output on standard output</p></td></tr><tr id="type-pmode.PARSE" class="anchored"><td class="def constructor"><a href="#type-pmode.PARSE" class="anchor"></a><code>| </code><code><span class="constructor">PARSE</span></code></td><td class="doc"><p>parse isla output and prettyprint it</p></td></tr><tr id="type-pmode.TYPE" class="anchored"><td class="def constructor"><a href="#type-pmode.TYPE" class="anchor"></a><code>| </code><code><span class="constructor">TYPE</span></code></td><td class="doc"><p>Type isla output and dump var types. Also dump the deduced register file</p></td></tr><tr id="type-pmode.RUN" class="anchored"><td class="def constructor"><a href="#type-pmode.RUN" class="anchor"></a><code>| </code><code><span class="constructor">RUN</span></code></td><td class="doc"><p>Run the the isla output on a test state and print all branches and states</p></td></tr><tr id="type-pmode.SIMP" class="anchored"><td class="def constructor"><a href="#type-pmode.SIMP" class="anchor"></a><code>| </code><code><span class="constructor">SIMP</span></code></td><td class="doc"><p>Run the the isla output on a test state and also print a simplified version</p></td></tr></table></dt><dd><p>The type of processing requested</p></dd></dl><dl><dt class="spec type" id="type-isla_mode"><a href="#type-isla_mode" class="anchor"></a><code><span class="keyword">type</span> isla_mode</code><code> = </code><table class="variant"><tr id="type-isla_mode.RAW" class="anchored"><td class="def constructor"><a href="#type-isla_mode.RAW" class="anchor"></a><code>| </code><code><span class="constructor">RAW</span></code></td><td class="doc"><p>Do not call isla and take the input test as if it was isla output</p></td></tr><tr id="type-isla_mode.ASM" class="anchored"><td class="def constructor"><a href="#type-isla_mode.ASM" class="anchor"></a><code>| </code><code><span class="constructor">ASM</span></code></td><td class="doc"><p>Call isla with text assembly</p></td></tr><tr id="type-isla_mode.HEX" class="anchored"><td class="def constructor"><a href="#type-isla_mode.HEX" class="anchor"></a><code>| </code><code><span class="constructor">HEX</span></code></td><td class="doc"><p>Call isla with text hexadecimal as binary encoding of instruction</p></td></tr><tr id="type-isla_mode.BIN" class="anchored"><td class="def constructor"><a href="#type-isla_mode.BIN" class="anchor"></a><code>| </code><code><span class="constructor">BIN</span></code></td><td class="doc"><p>Call isla with actually binary (for now 4 bytes)</p></td></tr></table></dt><dd><p>The input syntax</p></dd></dl><dl><dt class="spec type" id="type-imode"><a href="#type-imode" class="anchor"></a><code><span class="keyword">type</span> imode</code><code> = </code><table class="variant"><tr id="type-imode.CMD" class="anchored"><td class="def constructor"><a href="#type-imode.CMD" class="anchor"></a><code>| </code><code><span class="constructor">CMD</span></code></td><td class="doc"><p>Read the input as the main command line argument</p></td></tr><tr id="type-imode.FILE" class="anchored"><td class="def constructor"><a href="#type-imode.FILE" class="anchor"></a><code>| </code><code><span class="constructor">FILE</span></code></td><td class="doc"><p>Read the input in a file</p></td></tr><tr id="type-imode.ELF" class="anchored"><td class="def constructor"><a href="#type-imode.ELF" class="anchor"></a><code>| </code><code><span class="constructor">ELF</span> <span class="keyword">of</span> string</code></td><td class="doc"><p>Read the input from an elf symbol + offset. implies BIN for isla_mode</p></td></tr></table></dt><dd><p>The way input is taken</p></dd></dl><dl><dt class="spec value" id="val-arg"><a href="#val-arg" class="anchor"></a><code><span class="keyword">val</span> arg : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-direct"><a href="#val-direct" class="anchor"></a><code><span class="keyword">val</span> direct : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-bin"><a href="#val-bin" class="anchor"></a><code><span class="keyword">val</span> bin : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-hex"><a href="#val-hex" class="anchor"></a><code><span class="keyword">val</span> hex : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-noparse"><a href="#val-noparse" class="anchor"></a><code><span class="keyword">val</span> noparse : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-preprocess"><a href="#val-preprocess" class="anchor"></a><code><span class="keyword">val</span> preprocess : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-typer"><a href="#val-typer" class="anchor"></a><code><span class="keyword">val</span> typer : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-run"><a href="#val-run" class="anchor"></a><code><span class="keyword">val</span> run : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp"><a href="#val-simp" class="anchor"></a><code><span class="keyword">val</span> simp : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-file"><a href="#val-file" class="anchor"></a><code><span class="keyword">val</span> file : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-sym"><a href="#val-sym" class="anchor"></a><code><span class="keyword">val</span> sym : <span><span>string option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-input_f2m"><a href="#val-input_f2m" class="anchor"></a><code><span class="keyword">val</span> input_f2m : bool <span>&#45;&gt;</span> <span>string option</span> <span>&#45;&gt;</span> <span><a href="index.html#type-imode">imode</a> Cmdliner.Term.ret</span></code></dt><dd><p>Input flag to mode conversion</p></dd></dl><dl><dt class="spec value" id="val-imode_term"><a href="#val-imode_term" class="anchor"></a><code><span class="keyword">val</span> imode_term : <span><a href="index.html#type-imode">imode</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-input"><a href="#val-input" class="anchor"></a><code><span class="keyword">val</span> input : <a href="index.html#type-imode">imode</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span><span>(string * string)</span> Cmdliner.Term.ret</span></code></dt><dd><p>Input takes the imode and the main argument and returns the filename and input string</p></dd></dl><dl><dt class="spec value" id="val-input_term"><a href="#val-input_term" class="anchor"></a><code><span class="keyword">val</span> input_term : <span><span>(string * string)</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-isla_f2m"><a href="#val-isla_f2m" class="anchor"></a><code><span class="keyword">val</span> isla_f2m : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><a href="index.html#type-isla_mode">isla_mode</a> Cmdliner.Term.ret</span></code></dt><dd><p>Convert various flag describe the mode of operation into the mode of operation If sym is activated, then the default mode is BIN and not ASM</p></dd></dl><dl><dt class="spec value" id="val-isla_mode_term"><a href="#val-isla_mode_term" class="anchor"></a><code><span class="keyword">val</span> isla_mode_term : <span><a href="index.html#type-isla_mode">isla_mode</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-isla_mode_to_request"><a href="#val-isla_mode_to_request" class="anchor"></a><code><span class="keyword">val</span> isla_mode_to_request : <a href="index.html#type-isla_mode">isla_mode</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="../Server/index.html#type-request">Server.request</a></code></dt><dt class="spec value" id="val-isla_run"><a href="#val-isla_run" class="anchor"></a><code><span class="keyword">val</span> isla_run : <a href="index.html#type-isla_mode">isla_mode</a> <span>&#45;&gt;</span> <a href="../../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> <span>(string * string)</span> <span>&#45;&gt;</span> string * string * <a href="../Server/index.html#type-config">Server.config</a></code></dt><dd><p>Run isla and return a text trace with a filename (if mode is RAW than just return the trace and filename without isla)</p><p>If isla return multiple traces, just silently pick the first non-exceptional one</p></dd></dl><dl><dt class="spec value" id="val-isla_term"><a href="#val-isla_term" class="anchor"></a><code><span class="keyword">val</span> isla_term : <span><span>(string * string * <a href="../Server/index.html#type-config">Server.config</a>)</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-processing_f2m"><a href="#val-processing_f2m" class="anchor"></a><code><span class="keyword">val</span> processing_f2m : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-pmode">pmode</a></code></dt><dd><p>How far into the processing pipeline we go. We just pick the deepest option chosen</p></dd></dl><dl><dt class="spec value" id="val-pmode_term"><a href="#val-pmode_term" class="anchor"></a><code><span class="keyword">val</span> pmode_term : <span><a href="index.html#type-pmode">pmode</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-processing"><a href="#val-processing" class="anchor"></a><code><span class="keyword">val</span> processing : bool <span>&#45;&gt;</span> <a href="index.html#type-pmode">pmode</a> <span>&#45;&gt;</span> <span>(string * string * <a href="../Server/index.html#type-config">Server.config</a>)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Does the actual processing of the trace</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test (read-dwarf.Isla.Test)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Test</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Test</span></code></h1><p>This file about testing interaction with Isla for single instructions</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-SMT"><a href="#module-SMT" class="anchor"></a><code><span><span class="keyword">module</span> SMT</span><span> = <a href="../../Z3/index.html">Z3</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-pmode"><a href="#type-pmode" class="anchor"></a><code><span><span class="keyword">type</span> pmode</span><span> = </span></code><ol><li id="type-pmode.DUMP" class="def variant constructor anchored"><a href="#type-pmode.DUMP" class="anchor"></a><code><span>| </span><span><span class="constructor">DUMP</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Dump isla output on standard output</p><span class="comment-delim">*)</span></div></li><li id="type-pmode.PARSE" class="def variant constructor anchored"><a href="#type-pmode.PARSE" class="anchor"></a><code><span>| </span><span><span class="constructor">PARSE</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>parse isla output and prettyprint it</p><span class="comment-delim">*)</span></div></li><li id="type-pmode.TYPE" class="def variant constructor anchored"><a href="#type-pmode.TYPE" class="anchor"></a><code><span>| </span><span><span class="constructor">TYPE</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Type isla output and dump var types. Also dump the deduced register file</p><span class="comment-delim">*)</span></div></li><li id="type-pmode.RUN" class="def variant constructor anchored"><a href="#type-pmode.RUN" class="anchor"></a><code><span>| </span><span><span class="constructor">RUN</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Run the the isla output on a test state and print all branches and states</p><span class="comment-delim">*)</span></div></li><li id="type-pmode.SIMP" class="def variant constructor anchored"><a href="#type-pmode.SIMP" class="anchor"></a><code><span>| </span><span><span class="constructor">SIMP</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Run the the isla output on a test state and also print a simplified version</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The type of processing requested</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-isla_mode"><a href="#type-isla_mode" class="anchor"></a><code><span><span class="keyword">type</span> isla_mode</span><span> = </span></code><ol><li id="type-isla_mode.RAW" class="def variant constructor anchored"><a href="#type-isla_mode.RAW" class="anchor"></a><code><span>| </span><span><span class="constructor">RAW</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Do not call isla and take the input test as if it was isla output</p><span class="comment-delim">*)</span></div></li><li id="type-isla_mode.ASM" class="def variant constructor anchored"><a href="#type-isla_mode.ASM" class="anchor"></a><code><span>| </span><span><span class="constructor">ASM</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Call isla with text assembly</p><span class="comment-delim">*)</span></div></li><li id="type-isla_mode.HEX" class="def variant constructor anchored"><a href="#type-isla_mode.HEX" class="anchor"></a><code><span>| </span><span><span class="constructor">HEX</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Call isla with text hexadecimal as binary encoding of instruction</p><span class="comment-delim">*)</span></div></li><li id="type-isla_mode.BIN" class="def variant constructor anchored"><a href="#type-isla_mode.BIN" class="anchor"></a><code><span>| </span><span><span class="constructor">BIN</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Call isla with actually binary (for now 4 bytes)</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The input syntax</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-imode"><a href="#type-imode" class="anchor"></a><code><span><span class="keyword">type</span> imode</span><span> = </span></code><ol><li id="type-imode.CMD" class="def variant constructor anchored"><a href="#type-imode.CMD" class="anchor"></a><code><span>| </span><span><span class="constructor">CMD</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Read the input as the main command line argument</p><span class="comment-delim">*)</span></div></li><li id="type-imode.FILE" class="def variant constructor anchored"><a href="#type-imode.FILE" class="anchor"></a><code><span>| </span><span><span class="constructor">FILE</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Read the input in a file</p><span class="comment-delim">*)</span></div></li><li id="type-imode.ELF" class="def variant constructor anchored"><a href="#type-imode.ELF" class="anchor"></a><code><span>| </span><span><span class="constructor">ELF</span> <span class="keyword">of</span> string</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Read the input from an elf symbol + offset. implies BIN for isla_mode</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The way input is taken</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arg"><a href="#val-arg" class="anchor"></a><code><span><span class="keyword">val</span> arg : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-direct"><a href="#val-direct" class="anchor"></a><code><span><span class="keyword">val</span> direct : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bin"><a href="#val-bin" class="anchor"></a><code><span><span class="keyword">val</span> bin : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex"><a href="#val-hex" class="anchor"></a><code><span><span class="keyword">val</span> hex : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-noparse"><a href="#val-noparse" class="anchor"></a><code><span><span class="keyword">val</span> noparse : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-preprocess"><a href="#val-preprocess" class="anchor"></a><code><span><span class="keyword">val</span> preprocess : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-typer"><a href="#val-typer" class="anchor"></a><code><span><span class="keyword">val</span> typer : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run"><a href="#val-run" class="anchor"></a><code><span><span class="keyword">val</span> run : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp"><a href="#val-simp" class="anchor"></a><code><span><span class="keyword">val</span> simp : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-file"><a href="#val-file" class="anchor"></a><code><span><span class="keyword">val</span> file : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym"><a href="#val-sym" class="anchor"></a><code><span><span class="keyword">val</span> sym : <span><span>string option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_f2m"><a href="#val-input_f2m" class="anchor"></a><code><span><span class="keyword">val</span> input_f2m : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-imode">imode</a> <span class="xref-unresolved">Cmdliner</span>.Term.ret</span></span></code></div><div class="spec-doc"><p>Input flag to mode conversion</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-imode_term"><a href="#val-imode_term" class="anchor"></a><code><span><span class="keyword">val</span> imode_term : <span><a href="#type-imode">imode</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input"><a href="#val-input" class="anchor"></a><code><span><span class="keyword">val</span> input : <span><a href="#type-imode">imode</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(string * string)</span> <span class="xref-unresolved">Cmdliner</span>.Term.ret</span></span></code></div><div class="spec-doc"><p>Input takes the imode and the main argument and returns the filename and input string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_term"><a href="#val-input_term" class="anchor"></a><code><span><span class="keyword">val</span> input_term : <span><span>(string * string)</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_f2m"><a href="#val-isla_f2m" class="anchor"></a><code><span><span class="keyword">val</span> isla_f2m : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-isla_mode">isla_mode</a> <span class="xref-unresolved">Cmdliner</span>.Term.ret</span></span></code></div><div class="spec-doc"><p>Convert various flag describe the mode of operation into the mode of operation If sym is activated, then the default mode is BIN and not ASM</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_mode_term"><a href="#val-isla_mode_term" class="anchor"></a><code><span><span class="keyword">val</span> isla_mode_term : <span><a href="#type-isla_mode">isla_mode</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_mode_to_request"><a href="#val-isla_mode_to_request" class="anchor"></a><code><span><span class="keyword">val</span> isla_mode_to_request : <span><a href="#type-isla_mode">isla_mode</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="../Server/index.html#type-request">Server.request</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_run"><a href="#val-isla_run" class="anchor"></a><code><span><span class="keyword">val</span> isla_run : 
+  <span><a href="#type-isla_mode">isla_mode</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(string * string)</span> <span class="arrow">&#45;&gt;</span></span>
+  string * string * <a href="../Server/index.html#type-config">Server.config</a></span></code></div><div class="spec-doc"><p>Run isla and return a text trace with a filename (if mode is RAW than just return the trace and filename without isla)</p><p>If isla return multiple traces, just silently pick the first non-exceptional one</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_term"><a href="#val-isla_term" class="anchor"></a><code><span><span class="keyword">val</span> isla_term : <span><span>(string * string * <a href="../Server/index.html#type-config">Server.config</a>)</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-processing_f2m"><a href="#val-processing_f2m" class="anchor"></a><code><span><span class="keyword">val</span> processing_f2m : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-pmode">pmode</a></span></code></div><div class="spec-doc"><p>How far into the processing pipeline we go. We just pick the deepest option chosen</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pmode_term"><a href="#val-pmode_term" class="anchor"></a><code><span><span class="keyword">val</span> pmode_term : <span><a href="#type-pmode">pmode</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-processing"><a href="#val-processing" class="anchor"></a><code><span><span class="keyword">val</span> processing : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-pmode">pmode</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(string * string * <a href="../Server/index.html#type-config">Server.config</a>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Does the actual processing of the trace</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/Type/index.html b/doc/html/read-dwarf/Isla/Type/index.html
index cf92e84a..66a01a7d 100644
--- a/doc/html/read-dwarf/Isla/Type/index.html
+++ b/doc/html/read-dwarf/Isla/Type/index.html
@@ -1,2 +1,16 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Type (read-dwarf.Isla.Type)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Type</nav><h1>Module <code>Isla.Type</code></h1><p>This module is about type isla trace and register discovery.</p><p>The actual goal is dicovering the existence and type of registers from Isla traces, but this require type the trace with <a href="../index.html#type-ty"><code>ty</code></a> and thus full type checking of traces. We expect isla to be correct, so a type error would be very surprising.</p></header><dl><dt class="spec type" id="type-type_context"><a href="#type-type_context" class="anchor"></a><code><span class="keyword">type</span> type_context</code><code> = <span><a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></code></dt><dd><p>A context that associate Isla <a href="../index.html#type-ty"><span>types</span></a> to Isla variables</p></dd></dl><dl><dt class="spec type" id="type-lty"><a href="#type-lty" class="anchor"></a><code><span class="keyword">type</span> lty</code><code> = <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty</code></dt><dd><p>A group of the source range and type for an expression</p></dd></dl><dl><dt class="spec exception" id="exception-TypeError"><a href="#exception-TypeError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">TypeError</span> <span class="keyword">of</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * string</code></dt><dd><p>Exception that represent an Isla typing error</p></dd></dl><dl><dt class="spec value" id="val-tassert"><a href="#val-tassert" class="anchor"></a><code><span class="keyword">val</span> tassert : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> string <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> unit</code></dt><dd><p>Assert some properties for type correctness. Requires a lrng and a string error message</p></dd></dl><dl><dt class="spec value" id="val-expect_bool"><a href="#val-expect_bool" class="anchor"></a><code><span class="keyword">val</span> expect_bool : string <span>&#45;&gt;</span> <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty)</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-expect_bv"><a href="#val-expect_bv" class="anchor"></a><code><span class="keyword">val</span> expect_bv : string <span>&#45;&gt;</span> <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty)</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-expect_enum"><a href="#val-expect_enum" class="anchor"></a><code><span class="keyword">val</span> expect_enum : string <span>&#45;&gt;</span> <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty)</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-type_unop"><a href="#val-type_unop" class="anchor"></a><code><span class="keyword">val</span> type_unop : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.unop <span>&#45;&gt;</span> <a href="index.html#type-lty">lty</a> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty</code></dt><dt class="spec value" id="val-type_binop"><a href="#val-type_binop" class="anchor"></a><code><span class="keyword">val</span> type_binop : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.binop <span>&#45;&gt;</span> <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty)</span> <span>&#45;&gt;</span> <span>(<a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng * <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty)</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty</code></dt><dt class="spec value" id="val-type_manyop"><a href="#val-type_manyop" class="anchor"></a><code><span class="keyword">val</span> type_manyop : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.manyop <span>&#45;&gt;</span> <span><a href="index.html#type-lty">lty</a> list</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty</code></dt><dt class="spec value" id="val-type_valu"><a href="#val-type_valu" class="anchor"></a><code><span class="keyword">val</span> type_valu : <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <span>&#45;&gt;</span> <a href="index.html#type-type_context">type_context</a> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.valu <span>&#45;&gt;</span> <span><span>(<a href="../../State__Reg/Path/index.html#type-t">State.Reg.Path.t</a> * <a href="../../State/Reg/index.html#type-ty">State.Reg.ty</a>)</span> list</span></code></dt><dd><p>Take an Isla value and a context and give the list of field that correspond to that value. Those fields would need to be prefixed with the top register name before being added in <a href="../../State/Reg/index.html"><code>State.Reg</code></a></p></dd></dl><dl><dt class="spec value" id="val-ltype_expr"><a href="#val-ltype_expr" class="anchor"></a><code><span class="keyword">val</span> ltype_expr : <a href="index.html#type-type_context">type_context</a> <span>&#45;&gt;</span> <span><a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <a href="index.html#type-lty">lty</a></code></dt><dt class="spec value" id="val-type_expr"><a href="#val-type_expr" class="anchor"></a><code><span class="keyword">val</span> type_expr : <a href="index.html#type-type_context">type_context</a> <span>&#45;&gt;</span> <span><a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.lrng <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.exp</span> <span>&#45;&gt;</span> <a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty</code></dt><dt class="spec value" id="val-type_trc"><a href="#val-type_trc" class="anchor"></a><code><span class="keyword">val</span> type_trc : <span>?&#8288;tc:<span><a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span>&#45;&gt;</span> <span><a href="../../Isla__/index.html#module-Base">Isla__.Base</a>.ty <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></code></dt><dd><p>Add the new register found in the trace and returns the type context for free variables</p></dd></dl><dl><dt class="spec value" id="val-pp_tcontext"><a href="#val-pp_tcontext" class="anchor"></a><code><span class="keyword">val</span> pp_tcontext : <span>Isla_lang__.Isla_lang_ast.ty <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Print a type context for debugging</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Type (read-dwarf.Isla.Type)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Isla</a> &#x00BB; Type</nav><header class="odoc-preamble"><h1>Module <code><span>Isla.Type</span></code></h1><p>This module is about type isla trace and register discovery.</p><p>The actual goal is dicovering the existence and type of registers from Isla traces, but this require type the trace with <a href="../index.html#type-ty"><code>ty</code></a> and thus full type checking of traces. We expect isla to be correct, so a type error would be very surprising.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-type_context"><a href="#type-type_context" class="anchor"></a><code><span><span class="keyword">type</span> type_context</span><span> = <span><a href="../Base/index.html#type-ty">Base.ty</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span></code></div><div class="spec-doc"><p>A context that associate Isla <a href="../index.html#type-ty" title="ty">types</a> to Isla variables</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lty"><a href="#type-lty" class="anchor"></a><code><span><span class="keyword">type</span> lty</span><span> = <a href="../Base/index.html#type-lrng">Base.lrng</a> * <a href="../Base/index.html#type-ty">Base.ty</a></span></code></div><div class="spec-doc"><p>A group of the source range and type for an expression</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-TypeError"><a href="#exception-TypeError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">TypeError</span> <span class="keyword">of</span> <a href="../Base/index.html#type-lrng">Base.lrng</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla typing error</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tassert"><a href="#val-tassert" class="anchor"></a><code><span><span class="keyword">val</span> tassert : <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Assert some properties for type correctness. Requires a lrng and a string error message</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bool"><a href="#val-expect_bool" class="anchor"></a><code><span><span class="keyword">val</span> expect_bool : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../Base/index.html#type-lrng">Base.lrng</a> * <a href="../Base/index.html#type-ty">Base.ty</a>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_bv"><a href="#val-expect_bv" class="anchor"></a><code><span><span class="keyword">val</span> expect_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../Base/index.html#type-lrng">Base.lrng</a> * <a href="../Base/index.html#type-ty">Base.ty</a>)</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_enum"><a href="#val-expect_enum" class="anchor"></a><code><span><span class="keyword">val</span> expect_enum : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../Base/index.html#type-lrng">Base.lrng</a> * <a href="../Base/index.html#type-ty">Base.ty</a>)</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_unop"><a href="#val-type_unop" class="anchor"></a><code><span><span class="keyword">val</span> type_unop : <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-unop">Base.unop</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-lty">lty</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-ty">Base.ty</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_binop"><a href="#val-type_binop" class="anchor"></a><code><span><span class="keyword">val</span> type_binop : 
+  <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-binop">Base.binop</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../Base/index.html#type-lrng">Base.lrng</a> * <a href="../Base/index.html#type-ty">Base.ty</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../Base/index.html#type-lrng">Base.lrng</a> * <a href="../Base/index.html#type-ty">Base.ty</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../Base/index.html#type-ty">Base.ty</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_manyop"><a href="#val-type_manyop" class="anchor"></a><code><span><span class="keyword">val</span> type_manyop : <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-manyop">Base.manyop</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-lty">lty</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-ty">Base.ty</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_valu"><a href="#val-type_valu" class="anchor"></a><code><span><span class="keyword">val</span> type_valu : 
+  <span><a href="../Base/index.html#type-lrng">Base.lrng</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-type_context">type_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-valu">Base.valu</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<a href="../../State/Reg/Path/index.html#type-t">State.Reg.Path.t</a> * <a href="../../State/Reg/index.html#type-ty">State.Reg.ty</a>)</span> list</span></span></code></div><div class="spec-doc"><p>Take an Isla value and a context and give the list of field that correspond to that value. Those fields would need to be prefixed with the top register name before being added in <a href="../../State/Reg/index.html"><code>State.Reg</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ltype_expr"><a href="#val-ltype_expr" class="anchor"></a><code><span><span class="keyword">val</span> ltype_expr : <span><a href="#type-type_context">type_context</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="../Base/index.html#type-lrng">Base.lrng</a> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-lty">lty</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_expr"><a href="#val-type_expr" class="anchor"></a><code><span><span class="keyword">val</span> type_expr : <span><a href="#type-type_context">type_context</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="../Base/index.html#type-lrng">Base.lrng</a> <a href="../Base/index.html#type-exp">Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Base/index.html#type-ty">Base.ty</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-type_trc"><a href="#val-type_trc" class="anchor"></a><code><span><span class="keyword">val</span> type_trc : 
+  <span><span class="optlabel">?tc</span>:<span><a href="../Base/index.html#type-ty">Base.ty</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-rtrc">Base.rtrc</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-ty">Base.ty</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span></code></div><div class="spec-doc"><p>Add the new register found in the trace and returns the type context for free variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_tcontext"><a href="#val-pp_tcontext" class="anchor"></a><code><span><span class="keyword">val</span> pp_tcontext : 
+  <span><span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.ty <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Print a type context for debugging</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Isla/index.html b/doc/html/read-dwarf/Isla/index.html
index 1ee0a924..26d90f7f 100644
--- a/doc/html/read-dwarf/Isla/index.html
+++ b/doc/html/read-dwarf/Isla/index.html
@@ -1,2 +1,25 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Isla (read-dwarf.Isla)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Isla</nav><h1>Module <code>Isla</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="index.html#module-Base">Base</a></code></span></summary><aside><p>This module wraps all <code>isla-lang</code> functionality. No other module should directly touch the <code>Isla_lang</code> module.</p><p>The isla trace syntax is compose of <a href="index.html#type-event"><span>events</span></a> that a regrouped into <a href="index.html#type-trc"><span>traces</span></a>. There are a lot of possible events, and some of them are unsupported. in particular all the ones that deal with concurrency.</p><p>All the variable in isla traces are numbered. They are named <code>v28</code> in the syntax and are represented as a plain <code>int</code> in Ocaml. The structure of the traces is a mix of SMT declaration about those variable and actual processor events. SMT declaration use SMT expressions of type <a href="index.html#type-exp"><code>exp</code></a> which entirely distinct from <a href="../Ast/index.html#type-exp"><code>Ast.exp</code></a> (Use <a href="Conv/index.html"><code>Isla.Conv</code></a> to convert). On the contrary processor event do not contain direct SMT expressions but Sail values of type <a href="index.html#type-valu"><code>valu</code></a>. A <a href="index.html#type-valu"><code>valu</code></a> can be either a single symbolic variable, a concrete bitvector/boolean/enumeration value or a more complex sail structure with fields that contain other <a href="index.html#type-valu"><code>valu</code></a>s and some other things.</p><p>Event of reading and writing complex register like <code>PSTATE</code> in <code>AArch64</code> will provide the whole structure as a valu to be read or written. However, Those events may contain a accessor list that implies that only specific field of the struct are written or read. This useful, because of the flat representation of registers in <a href="../State/Reg/index.html"><code>State.Reg</code></a>: each field is considered to be a separate register.</p><p>The isla types are polymorphic over the annotation because that comes from <code>isla-lang</code>, but in practice the only annotation I use the source position of type <a href="index.html#type-lrng"><code>lrng</code></a>, that's why there is a set of aliases starting with <code>r</code>.</p></aside><section><header><h2 id="aliases"><a href="#aliases" class="anchor"></a>Aliases</h2></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Isla_lang.AST</code></span></summary><dl><dt class="spec type" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span class="keyword">type</span> enum</code><code> = int * int</code></dt><dt class="spec type" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span class="keyword">type</span> lrng</code><code> = Isla_lang__Isla_lang_ast.lrng</code><code> = </code><table class="variant"><tr id="type-lrng.UnknownRng" class="anchored"><td class="def constructor"><a href="#type-lrng.UnknownRng" class="anchor"></a><code>| </code><code><span class="constructor">UnknownRng</span></code></td></tr><tr id="type-lrng.Generated" class="anchored"><td class="def constructor"><a href="#type-lrng.Generated" class="anchor"></a><code>| </code><code><span class="constructor">Generated</span> <span class="keyword">of</span> <a href="index.html#type-lrng">lrng</a></code></td></tr><tr id="type-lrng.Range" class="anchored"><td class="def constructor"><a href="#type-lrng.Range" class="anchor"></a><code>| </code><code><span class="constructor">Range</span> <span class="keyword">of</span> Stdlib.Lexing.position * Stdlib.Lexing.position</code></td></tr></table></dt></dl><dl><dt class="spec exception" id="exception-Parse_error_locn"><a href="#exception-Parse_error_locn" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Parse_error_locn</span> <span class="keyword">of</span> <a href="index.html#type-lrng">lrng</a> * string</code></dt></dl><dl><dt class="spec value" id="val-pp_lpos"><a href="#val-pp_lpos" class="anchor"></a><code><span class="keyword">val</span> pp_lpos : Stdlib.Lexing.position <span>&#45;&gt;</span> PPrint.document</code></dt><dt class="spec value" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span class="keyword">val</span> pp_lrng : <a href="index.html#type-lrng">lrng</a> <span>&#45;&gt;</span> PPrint.document</code></dt></dl><dl><dt class="spec type" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span class="keyword">type</span> bvmanyarith</code><code> = Isla_lang__Isla_lang_ast.bvmanyarith</code><code> = </code><table class="variant"><tr id="type-bvmanyarith.Bvand" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code>| </code><code><span class="constructor">Bvand</span></code></td></tr><tr id="type-bvmanyarith.Bvor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code>| </code><code><span class="constructor">Bvor</span></code></td></tr><tr id="type-bvmanyarith.Bvxor" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxor</span></code></td></tr><tr id="type-bvmanyarith.Bvadd" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code>| </code><code><span class="constructor">Bvadd</span></code></td></tr><tr id="type-bvmanyarith.Bvmul" class="anchored"><td class="def constructor"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code>| </code><code><span class="constructor">Bvmul</span></code></td></tr></table></dt><dt class="spec type" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span class="keyword">type</span> bvcomp</code><code> = Isla_lang__Isla_lang_ast.bvcomp</code><code> = </code><table class="variant"><tr id="type-bvcomp.Bvult" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvult" class="anchor"></a><code>| </code><code><span class="constructor">Bvult</span></code></td></tr><tr id="type-bvcomp.Bvslt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code>| </code><code><span class="constructor">Bvslt</span></code></td></tr><tr id="type-bvcomp.Bvule" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvule" class="anchor"></a><code>| </code><code><span class="constructor">Bvule</span></code></td></tr><tr id="type-bvcomp.Bvsle" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code>| </code><code><span class="constructor">Bvsle</span></code></td></tr><tr id="type-bvcomp.Bvuge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code>| </code><code><span class="constructor">Bvuge</span></code></td></tr><tr id="type-bvcomp.Bvsge" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code>| </code><code><span class="constructor">Bvsge</span></code></td></tr><tr id="type-bvcomp.Bvugt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code>| </code><code><span class="constructor">Bvugt</span></code></td></tr><tr id="type-bvcomp.Bvsgt" class="anchored"><td class="def constructor"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code>| </code><code><span class="constructor">Bvsgt</span></code></td></tr></table></dt><dt class="spec type" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span class="keyword">type</span> bvarith</code><code> = Isla_lang__Isla_lang_ast.bvarith</code><code> = </code><table class="variant"><tr id="type-bvarith.Bvnand" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnand" class="anchor"></a><code>| </code><code><span class="constructor">Bvnand</span></code></td></tr><tr id="type-bvarith.Bvnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvnor</span></code></td></tr><tr id="type-bvarith.Bvxnor" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code>| </code><code><span class="constructor">Bvxnor</span></code></td></tr><tr id="type-bvarith.Bvsub" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsub" class="anchor"></a><code>| </code><code><span class="constructor">Bvsub</span></code></td></tr><tr id="type-bvarith.Bvudiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvudiv</span></code></td></tr><tr id="type-bvarith.Bvudivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvudivi</span></code></td></tr><tr id="type-bvarith.Bvsdiv" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdiv</span></code></td></tr><tr id="type-bvarith.Bvsdivi" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code>| </code><code><span class="constructor">Bvsdivi</span></code></td></tr><tr id="type-bvarith.Bvurem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvurem" class="anchor"></a><code>| </code><code><span class="constructor">Bvurem</span></code></td></tr><tr id="type-bvarith.Bvsrem" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code>| </code><code><span class="constructor">Bvsrem</span></code></td></tr><tr id="type-bvarith.Bvsmod" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code>| </code><code><span class="constructor">Bvsmod</span></code></td></tr><tr id="type-bvarith.Bvshl" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvshl" class="anchor"></a><code>| </code><code><span class="constructor">Bvshl</span></code></td></tr><tr id="type-bvarith.Bvlshr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code>| </code><code><span class="constructor">Bvlshr</span></code></td></tr><tr id="type-bvarith.Bvashr" class="anchored"><td class="def constructor"><a href="#type-bvarith.Bvashr" class="anchor"></a><code>| </code><code><span class="constructor">Bvashr</span></code></td></tr></table></dt><dt class="spec type" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span class="keyword">type</span> manyop</code><code> = Isla_lang__Isla_lang_ast.manyop</code><code> = </code><table class="variant"><tr id="type-manyop.And" class="anchored"><td class="def constructor"><a href="#type-manyop.And" class="anchor"></a><code>| </code><code><span class="constructor">And</span></code></td></tr><tr id="type-manyop.Or" class="anchored"><td class="def constructor"><a href="#type-manyop.Or" class="anchor"></a><code>| </code><code><span class="constructor">Or</span></code></td></tr><tr id="type-manyop.Bvmanyarith" class="anchored"><td class="def constructor"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="index.html#type-bvmanyarith">bvmanyarith</a></code></td></tr><tr id="type-manyop.Concat" class="anchored"><td class="def constructor"><a href="#type-manyop.Concat" class="anchor"></a><code>| </code><code><span class="constructor">Concat</span></code></td></tr></table></dt><dt class="spec type" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span class="keyword">type</span> unop</code><code> = Isla_lang__Isla_lang_ast.unop</code><code> = </code><table class="variant"><tr id="type-unop.Not" class="anchored"><td class="def constructor"><a href="#type-unop.Not" class="anchor"></a><code>| </code><code><span class="constructor">Not</span></code></td></tr><tr id="type-unop.Bvnot" class="anchored"><td class="def constructor"><a href="#type-unop.Bvnot" class="anchor"></a><code>| </code><code><span class="constructor">Bvnot</span></code></td></tr><tr id="type-unop.Bvredand" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredand" class="anchor"></a><code>| </code><code><span class="constructor">Bvredand</span></code></td></tr><tr id="type-unop.Bvredor" class="anchored"><td class="def constructor"><a href="#type-unop.Bvredor" class="anchor"></a><code>| </code><code><span class="constructor">Bvredor</span></code></td></tr><tr id="type-unop.Bvneg" class="anchored"><td class="def constructor"><a href="#type-unop.Bvneg" class="anchor"></a><code>| </code><code><span class="constructor">Bvneg</span></code></td></tr><tr id="type-unop.Extract" class="anchored"><td class="def constructor"><a href="#type-unop.Extract" class="anchor"></a><code>| </code><code><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-unop.ZeroExtend" class="anchored"><td class="def constructor"><a href="#type-unop.ZeroExtend" class="anchor"></a><code>| </code><code><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-unop.SignExtend" class="anchored"><td class="def constructor"><a href="#type-unop.SignExtend" class="anchor"></a><code>| </code><code><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span class="keyword">type</span> binop</code><code> = Isla_lang__Isla_lang_ast.binop</code><code> = </code><table class="variant"><tr id="type-binop.Eq" class="anchored"><td class="def constructor"><a href="#type-binop.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span></code></td></tr><tr id="type-binop.Bvarith" class="anchored"><td class="def constructor"><a href="#type-binop.Bvarith" class="anchor"></a><code>| </code><code><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="index.html#type-bvarith">bvarith</a></code></td></tr><tr id="type-binop.Bvcomp" class="anchored"><td class="def constructor"><a href="#type-binop.Bvcomp" class="anchor"></a><code>| </code><code><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="index.html#type-bvcomp">bvcomp</a></code></td></tr></table></dt><dt class="spec type" id="type-accessor"><a href="#type-accessor" class="anchor"></a><code><span class="keyword">type</span> accessor</code><code> = Isla_lang__Isla_lang_ast.accessor</code><code> = </code><table class="variant"><tr id="type-accessor.Field" class="anchored"><td class="def constructor"><a href="#type-accessor.Field" class="anchor"></a><code>| </code><code><span class="constructor">Field</span> <span class="keyword">of</span> string</code></td></tr></table></dt><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> ty</code><code> = Isla_lang__Isla_lang_ast.ty</code><code> = </code><table class="variant"><tr id="type-ty.Ty_Bool" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Bool</span></code></td></tr><tr id="type-ty.Ty_BitVec" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code>| </code><code><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Enum" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-ty.Ty_Array" class="anchored"><td class="def constructor"><a href="#type-ty.Ty_Array" class="anchor"></a><code>| </code><code><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <a href="index.html#type-ty">ty</a> * <a href="index.html#type-ty">ty</a></code></td></tr></table></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>'a exp</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.exp</span></code><code> = </code><table class="variant"><tr id="type-exp.Var" class="anchored"><td class="def constructor"><a href="#type-exp.Var" class="anchor"></a><code>| </code><code><span class="constructor">Var</span> <span class="keyword">of</span> int * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bits" class="anchored"><td class="def constructor"><a href="#type-exp.Bits" class="anchor"></a><code>| </code><code><span class="constructor">Bits</span> <span class="keyword">of</span> string * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Bool" class="anchored"><td class="def constructor"><a href="#type-exp.Bool" class="anchor"></a><code>| </code><code><span class="constructor">Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Enum" class="anchored"><td class="def constructor"><a href="#type-exp.Enum" class="anchor"></a><code>| </code><code><span class="constructor">Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Unop" class="anchored"><td class="def constructor"><a href="#type-exp.Unop" class="anchor"></a><code>| </code><code><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Binop" class="anchored"><td class="def constructor"><a href="#type-exp.Binop" class="anchor"></a><code>| </code><code><span class="constructor">Binop</span> <span class="keyword">of</span> <a href="index.html#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Manyop" class="anchored"><td class="def constructor"><a href="#type-exp.Manyop" class="anchor"></a><code>| </code><code><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp.Ite" class="anchored"><td class="def constructor"><a href="#type-exp.Ite" class="anchor"></a><code>| </code><code><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-valu"><a href="#type-valu" class="anchor"></a><code><span class="keyword">type</span> valu</code><code> = Isla_lang__Isla_lang_ast.valu</code><code> = </code><table class="variant"><tr id="type-valu.Val_Symbolic" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Symbolic" class="anchor"></a><code>| </code><code><span class="constructor">Val_Symbolic</span> <span class="keyword">of</span> int</code></td></tr><tr id="type-valu.Val_Bool" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Bool" class="anchor"></a><code>| </code><code><span class="constructor">Val_Bool</span> <span class="keyword">of</span> bool</code></td></tr><tr id="type-valu.Val_I" class="anchored"><td class="def constructor"><a href="#type-valu.Val_I" class="anchor"></a><code>| </code><code><span class="constructor">Val_I</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-valu.Val_Bits" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Bits" class="anchor"></a><code>| </code><code><span class="constructor">Val_Bits</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu.Val_Enum" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Enum" class="anchor"></a><code>| </code><code><span class="constructor">Val_Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a></code></td></tr><tr id="type-valu.Val_String" class="anchored"><td class="def constructor"><a href="#type-valu.Val_String" class="anchor"></a><code>| </code><code><span class="constructor">Val_String</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu.Val_Unit" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Unit" class="anchor"></a><code>| </code><code><span class="constructor">Val_Unit</span></code></td></tr><tr id="type-valu.Val_NamedUnit" class="anchored"><td class="def constructor"><a href="#type-valu.Val_NamedUnit" class="anchor"></a><code>| </code><code><span class="constructor">Val_NamedUnit</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu.Val_Vector" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Vector" class="anchor"></a><code>| </code><code><span class="constructor">Val_Vector</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu.Val_List" class="anchored"><td class="def constructor"><a href="#type-valu.Val_List" class="anchor"></a><code>| </code><code><span class="constructor">Val_List</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu.Val_Struct" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Struct" class="anchor"></a><code>| </code><code><span class="constructor">Val_Struct</span> <span class="keyword">of</span> <span><span>(string * <a href="index.html#type-valu">valu</a>)</span> list</span></code></td></tr><tr id="type-valu.Val_Poison" class="anchored"><td class="def constructor"><a href="#type-valu.Val_Poison" class="anchor"></a><code>| </code><code><span class="constructor">Val_Poison</span></code></td></tr></table></dt><dt class="spec type" id="type-accessor_list"><a href="#type-accessor_list" class="anchor"></a><code><span class="keyword">type</span> accessor_list</code><code> = Isla_lang__Isla_lang_ast.accessor_list</code><code> = </code><table class="variant"><tr id="type-accessor_list.Nil" class="anchored"><td class="def constructor"><a href="#type-accessor_list.Nil" class="anchor"></a><code>| </code><code><span class="constructor">Nil</span></code></td></tr><tr id="type-accessor_list.Cons" class="anchored"><td class="def constructor"><a href="#type-accessor_list.Cons" class="anchor"></a><code>| </code><code><span class="constructor">Cons</span> <span class="keyword">of</span> <span><a href="index.html#type-accessor">accessor</a> list</span></code></td></tr></table></dt><dt class="spec type" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span class="keyword">type</span> <span>'a smt</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.smt</span></code><code> = </code><table class="variant"><tr id="type-smt.DeclareConst" class="anchored"><td class="def constructor"><a href="#type-smt.DeclareConst" class="anchor"></a><code>| </code><code><span class="constructor">DeclareConst</span> <span class="keyword">of</span> int * <a href="index.html#type-ty">ty</a></code></td></tr><tr id="type-smt.DefineConst" class="anchored"><td class="def constructor"><a href="#type-smt.DefineConst" class="anchor"></a><code>| </code><code><span class="constructor">DefineConst</span> <span class="keyword">of</span> int * <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.Assert" class="anchored"><td class="def constructor"><a href="#type-smt.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-exp">exp</a></span></code></td></tr><tr id="type-smt.DefineEnum" class="anchored"><td class="def constructor"><a href="#type-smt.DefineEnum" class="anchor"></a><code>| </code><code><span class="constructor">DefineEnum</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dt class="spec type" id="type-valu_option"><a href="#type-valu_option" class="anchor"></a><code><span class="keyword">type</span> valu_option</code><code> = <span><a href="index.html#type-valu">valu</a> option</span></code></dt><dt class="spec type" id="type-valu_concrete"><a href="#type-valu_concrete" class="anchor"></a><code><span class="keyword">type</span> valu_concrete</code><code> = Isla_lang__Isla_lang_ast.valu_concrete</code><code> = </code><table class="variant"><tr id="type-valu_concrete.CVal_Bool" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Bool" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Bool</span> <span class="keyword">of</span> bool</code></td></tr><tr id="type-valu_concrete.CVal_I" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_I" class="anchor"></a><code>| </code><code><span class="constructor">CVal_I</span> <span class="keyword">of</span> int * int</code></td></tr><tr id="type-valu_concrete.CVal_Bits" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Bits" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Bits</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu_concrete.CVal_Enum" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Enum" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a></code></td></tr><tr id="type-valu_concrete.CVal_String" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_String" class="anchor"></a><code>| </code><code><span class="constructor">CVal_String</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu_concrete.CVal_Unit" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Unit" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Unit</span></code></td></tr><tr id="type-valu_concrete.CVal_NamedUnit" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_NamedUnit" class="anchor"></a><code>| </code><code><span class="constructor">CVal_NamedUnit</span> <span class="keyword">of</span> string</code></td></tr><tr id="type-valu_concrete.CVal_Vector" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Vector" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Vector</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu_concrete.CVal_List" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_List" class="anchor"></a><code>| </code><code><span class="constructor">CVal_List</span> <span class="keyword">of</span> <span><a href="index.html#type-valu">valu</a> list</span></code></td></tr><tr id="type-valu_concrete.CVal_Struct" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Struct" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Struct</span> <span class="keyword">of</span> <span><span>(string * <a href="index.html#type-valu">valu</a>)</span> list</span></code></td></tr><tr id="type-valu_concrete.CVal_Poison" class="anchored"><td class="def constructor"><a href="#type-valu_concrete.CVal_Poison" class="anchor"></a><code>| </code><code><span class="constructor">CVal_Poison</span></code></td></tr></table></dt><dt class="spec type" id="type-event"><a href="#type-event" class="anchor"></a><code><span class="keyword">type</span> <span>'a event</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.event</span></code><code> = </code><table class="variant"><tr id="type-event.Smt" class="anchored"><td class="def constructor"><a href="#type-event.Smt" class="anchor"></a><code>| </code><code><span class="constructor">Smt</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-smt">smt</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Branch" class="anchored"><td class="def constructor"><a href="#type-event.Branch" class="anchor"></a><code>| </code><code><span class="constructor">Branch</span> <span class="keyword">of</span> int * string * <span class="type-var">'a</span></code></td></tr><tr id="type-event.ReadReg" class="anchored"><td class="def constructor"><a href="#type-event.ReadReg" class="anchor"></a><code>| </code><code><span class="constructor">ReadReg</span> <span class="keyword">of</span> string * <a href="index.html#type-accessor_list">accessor_list</a> * <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.WriteReg" class="anchored"><td class="def constructor"><a href="#type-event.WriteReg" class="anchor"></a><code>| </code><code><span class="constructor">WriteReg</span> <span class="keyword">of</span> string * <a href="index.html#type-accessor_list">accessor_list</a> * <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.ReadMem" class="anchored"><td class="def constructor"><a href="#type-event.ReadMem" class="anchor"></a><code>| </code><code><span class="constructor">ReadMem</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * int * <a href="index.html#type-valu_option">valu_option</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.WriteMem" class="anchored"><td class="def constructor"><a href="#type-event.WriteMem" class="anchor"></a><code>| </code><code><span class="constructor">WriteMem</span> <span class="keyword">of</span> int * <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * int * <a href="index.html#type-valu_option">valu_option</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.BranchAddress" class="anchored"><td class="def constructor"><a href="#type-event.BranchAddress" class="anchor"></a><code>| </code><code><span class="constructor">BranchAddress</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Barrier" class="anchored"><td class="def constructor"><a href="#type-event.Barrier" class="anchor"></a><code>| </code><code><span class="constructor">Barrier</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.CacheOp" class="anchored"><td class="def constructor"><a href="#type-event.CacheOp" class="anchor"></a><code>| </code><code><span class="constructor">CacheOp</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.MarkReg" class="anchored"><td class="def constructor"><a href="#type-event.MarkReg" class="anchor"></a><code>| </code><code><span class="constructor">MarkReg</span> <span class="keyword">of</span> string * string * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Cycle" class="anchored"><td class="def constructor"><a href="#type-event.Cycle" class="anchor"></a><code>| </code><code><span class="constructor">Cycle</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr><tr id="type-event.Instr" class="anchored"><td class="def constructor"><a href="#type-event.Instr" class="anchor"></a><code>| </code><code><span class="constructor">Instr</span> <span class="keyword">of</span> <a href="index.html#type-valu">valu</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-event.Sleeping" class="anchored"><td class="def constructor"><a href="#type-event.Sleeping" class="anchor"></a><code>| </code><code><span class="constructor">Sleeping</span> <span class="keyword">of</span> int * <span class="type-var">'a</span></code></td></tr><tr id="type-event.WakeRequest" class="anchored"><td class="def constructor"><a href="#type-event.WakeRequest" class="anchor"></a><code>| </code><code><span class="constructor">WakeRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr><tr id="type-event.SleepRequest" class="anchored"><td class="def constructor"><a href="#type-event.SleepRequest" class="anchor"></a><code>| </code><code><span class="constructor">SleepRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr></table></dt><dt class="spec type" id="type-trc"><a href="#type-trc" class="anchor"></a><code><span class="keyword">type</span> <span>'a trc</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.trc</span></code><code> = </code><table class="variant"><tr id="type-trc.Trace" class="anchored"><td class="def constructor"><a href="#type-trc.Trace" class="anchor"></a><code>| </code><code><span class="constructor">Trace</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="index.html#type-event">event</a></span> list</span></code></td></tr></table></dt><dt class="spec type" id="type-exp_val"><a href="#type-exp_val" class="anchor"></a><code><span class="keyword">type</span> <span>'a exp_val</span></code><code> = <span><span class="type-var">'a</span> Isla_lang__Isla_lang_ast.exp_val</span></code><code> = </code><table class="variant"><tr id="type-exp_val.EV_Bits" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Bits" class="anchor"></a><code>| </code><code><span class="constructor">EV_Bits</span> <span class="keyword">of</span> string * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Bool" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Bool" class="anchor"></a><code>| </code><code><span class="constructor">EV_Bool</span> <span class="keyword">of</span> bool * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Enum" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Enum" class="anchor"></a><code>| </code><code><span class="constructor">EV_Enum</span> <span class="keyword">of</span> <a href="index.html#type-enum">enum</a> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Unop" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Unop" class="anchor"></a><code>| </code><code><span class="constructor">EV_Unop</span> <span class="keyword">of</span> <a href="index.html#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Binop" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Binop" class="anchor"></a><code>| </code><code><span class="constructor">EV_Binop</span> <span class="keyword">of</span> <a href="index.html#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Manyop" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Manyop" class="anchor"></a><code>| </code><code><span class="constructor">EV_Manyop</span> <span class="keyword">of</span> <a href="index.html#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> list</span> * <span class="type-var">'a</span></code></td></tr><tr id="type-exp_val.EV_Ite" class="anchored"><td class="def constructor"><a href="#type-exp_val.EV_Ite" class="anchor"></a><code>| </code><code><span class="constructor">EV_Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-exp_val">exp_val</a></span> * <span class="type-var">'a</span></code></td></tr></table></dt></dl></details></div></div></div><div class="spec module" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span class="keyword">module</span> Lexer = Isla_lang.Lexer</code></div><div class="spec module" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span class="keyword">module</span> Parser = Isla_lang.Parser</code></div><dl><dt class="spec type" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span class="keyword">type</span> loc</code><code> = Stdlib.Lexing.position</code></dt><dt class="spec type" id="type-rtrc"><a href="#type-rtrc" class="anchor"></a><code><span class="keyword">type</span> rtrc</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-trc">trc</a></span></code></dt><dd><p>The type of raw traces out of the parser</p></dd></dl><dl><dt class="spec type" id="type-revent"><a href="#type-revent" class="anchor"></a><code><span class="keyword">type</span> revent</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-event">event</a></span></code></dt><dd><p>The type of raw events out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span class="keyword">type</span> rsmt</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-smt">smt</a></span></code></dt><dd><p>The type of raw SMT declaration out of the parser</p></dd></dl><dl><dt class="spec type" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span class="keyword">type</span> rexp</code><code> = <span><a href="index.html#type-lrng">lrng</a> <a href="index.html#type-exp">exp</a></span></code></dt><dd><p>The type of raw expressions out of the parser</p></dd></dl></section><section><header><h2 id="islatrace-parsing"><a href="#islatrace-parsing" class="anchor"></a>IslaTrace parsing</h2></header><dl><dt class="spec exception" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla parsing error</p></dd></dl><dl><dt class="spec exception" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">LexError</span> <span class="keyword">of</span> <a href="index.html#type-loc">loc</a> * string</code></dt><dd><p>Exception that represent an Isla lexing error</p></dd></dl><dl><dt class="spec type" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span class="keyword">type</span> lexer</code><code> = Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#module-Parser">Parser</a>.token</code></dt><dt class="spec type" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span class="keyword">type</span> <span>'a parser</span></code><code> = <a href="index.html#type-lexer">lexer</a> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec value" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span class="keyword">val</span> parse : <span><span class="type-var">'a</span> <a href="index.html#type-parser">parser</a></span> <span>&#45;&gt;</span> <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-parse_exp"><a href="#val-parse_exp" class="anchor"></a><code><span class="keyword">val</span> parse_exp : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-rexp">rexp</a></code></dt><dd><p>Parse a single Isla expression from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span class="keyword">val</span> parse_exp_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-rexp">rexp</a></code></dt><dd><p>Parse a single Isla expression from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span class="keyword">val</span> parse_exp_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <a href="index.html#type-rexp">rexp</a></code></dt><dd><p>Parse a single Isla expression from a channel</p></dd></dl><dl><dt class="spec value" id="val-parse_trc"><a href="#val-parse_trc" class="anchor"></a><code><span class="keyword">val</span> parse_trc : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.Lexing.lexbuf <span>&#45;&gt;</span> <a href="index.html#type-rtrc">rtrc</a></code></dt><dd><p>Parse an Isla trace from a Lexing.lexbuf</p></dd></dl><dl><dt class="spec value" id="val-parse_trc_string"><a href="#val-parse_trc_string" class="anchor"></a><code><span class="keyword">val</span> parse_trc_string : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-rtrc">rtrc</a></code></dt><dd><p>Parse an Isla trace from a string</p></dd></dl><dl><dt class="spec value" id="val-parse_trc_channel"><a href="#val-parse_trc_channel" class="anchor"></a><code><span class="keyword">val</span> parse_trc_channel : <span>?&#8288;filename:string</span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <a href="index.html#type-rtrc">rtrc</a></code></dt><dd><p>Parse an Isla trace from a channel</p></dd></dl></section><section><header><h2 id="islatrace-pretty-printing"><a href="#islatrace-pretty-printing" class="anchor"></a>IslaTrace pretty printing</h2></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Isla_lang.PP</code></span></summary><dl><dt class="spec value" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_raw_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span class="keyword">val</span> pp_raw_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span class="keyword">val</span> pp_raw_enum : Isla_lang__.Isla_lang_ast.enum <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span class="keyword">val</span> pp_raw_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span class="keyword">val</span> pp_raw_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span class="keyword">val</span> pp_raw_ty : Isla_lang__.Isla_lang_ast.ty <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_unop : Isla_lang__.Isla_lang_ast.unop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvarith : Isla_lang__.Isla_lang_ast.bvarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvcomp : Isla_lang__.Isla_lang_ast.bvcomp <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_binop : Isla_lang__.Isla_lang_ast.binop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_raw_bvmanyarith : Isla_lang__.Isla_lang_ast.bvmanyarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_raw_manyop : Isla_lang__.Isla_lang_ast.manyop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_exp_val"><a href="#val-pp_raw_exp_val" class="anchor"></a><code><span class="keyword">val</span> pp_raw_exp_val : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp_val</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span class="keyword">val</span> pp_raw_smt : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.smt</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_valu"><a href="#val-pp_raw_valu" class="anchor"></a><code><span class="keyword">val</span> pp_raw_valu : Isla_lang__.Isla_lang_ast.valu <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_selem"><a href="#val-pp_raw_selem" class="anchor"></a><code><span class="keyword">val</span> pp_raw_selem : <span>(string * Isla_lang__.Isla_lang_ast.valu)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_valu_concrete"><a href="#val-pp_raw_valu_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_raw_valu_concrete : Isla_lang__.Isla_lang_ast.valu_concrete <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_selem_concrete"><a href="#val-pp_raw_selem_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_raw_selem_concrete : <span>(string * Isla_lang__.Isla_lang_ast.valu_concrete)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_accessor"><a href="#val-pp_raw_accessor" class="anchor"></a><code><span class="keyword">val</span> pp_raw_accessor : Isla_lang__.Isla_lang_ast.accessor <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_accessor_list"><a href="#val-pp_raw_accessor_list" class="anchor"></a><code><span class="keyword">val</span> pp_raw_accessor_list : Isla_lang__.Isla_lang_ast.accessor_list <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_valu_option"><a href="#val-pp_raw_valu_option" class="anchor"></a><code><span class="keyword">val</span> pp_raw_valu_option : Isla_lang__.Isla_lang_ast.valu_option <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_event"><a href="#val-pp_raw_event" class="anchor"></a><code><span class="keyword">val</span> pp_raw_event : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.event</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_raw_trc"><a href="#val-pp_raw_trc" class="anchor"></a><code><span class="keyword">val</span> pp_raw_trc : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.trc</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span class="keyword">val</span> pp_vvar : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span class="keyword">val</span> pp_name : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span class="keyword">val</span> pp_enum_ty : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span class="keyword">val</span> pp_enum : Isla_lang__.Isla_lang_ast.enum <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span class="keyword">val</span> pp_int : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span class="keyword">val</span> pp_bvi : int <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span class="keyword">val</span> pp_bv : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span class="keyword">val</span> pp_str : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span class="keyword">val</span> pp_j : int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span class="keyword">val</span> pp_ty : Isla_lang__.Isla_lang_ast.ty <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span class="keyword">val</span> pp_bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span class="keyword">val</span> pp_unop : Isla_lang__.Isla_lang_ast.unop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvarith : Isla_lang__.Isla_lang_ast.bvarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span class="keyword">val</span> pp_bvcomp : Isla_lang__.Isla_lang_ast.bvcomp <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span class="keyword">val</span> pp_binop : Isla_lang__.Isla_lang_ast.binop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span class="keyword">val</span> pp_bvmanyarith : Isla_lang__.Isla_lang_ast.bvmanyarith <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span class="keyword">val</span> pp_manyop : Isla_lang__.Isla_lang_ast.manyop <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_exp_val"><a href="#val-pp_exp_val" class="anchor"></a><code><span class="keyword">val</span> pp_exp_val : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.exp_val</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.smt</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_valu"><a href="#val-pp_valu" class="anchor"></a><code><span class="keyword">val</span> pp_valu : Isla_lang__.Isla_lang_ast.valu <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_selem"><a href="#val-pp_selem" class="anchor"></a><code><span class="keyword">val</span> pp_selem : <span>(string * Isla_lang__.Isla_lang_ast.valu)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_valu_concrete"><a href="#val-pp_valu_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_valu_concrete : Isla_lang__.Isla_lang_ast.valu_concrete <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_selem_concrete"><a href="#val-pp_selem_concrete" class="anchor"></a><code><span class="keyword">val</span> pp_selem_concrete : <span>(string * Isla_lang__.Isla_lang_ast.valu_concrete)</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_accessor"><a href="#val-pp_accessor" class="anchor"></a><code><span class="keyword">val</span> pp_accessor : Isla_lang__.Isla_lang_ast.accessor <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_accessor_list"><a href="#val-pp_accessor_list" class="anchor"></a><code><span class="keyword">val</span> pp_accessor_list : Isla_lang__.Isla_lang_ast.accessor_list <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_valu_option"><a href="#val-pp_valu_option" class="anchor"></a><code><span class="keyword">val</span> pp_valu_option : Isla_lang__.Isla_lang_ast.valu_option <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span class="keyword">val</span> pp_event : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.event</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_trc"><a href="#val-pp_trc" class="anchor"></a><code><span class="keyword">val</span> pp_trc : <span><span class="type-var">'a</span> Isla_lang__.Isla_lang_ast.trc</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></details></div></div></div></section></details></div></div></div><dl><dt class="spec module" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span class="keyword">module</span> <a href="Base/index.html">Base</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module wraps all <code>isla-lang</code> functionality. No other module should directly touch the <code>Isla_lang</code> module.</p></dd></dl><dl><dt class="spec module" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span class="keyword">module</span> <a href="Cache/index.html">Cache</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide a caching system for isla trace on top of <a href="Server/index.html"><code>Server</code></a>.</p></dd></dl><div class="spec module" id="module-Conv"><a href="#module-Conv" class="anchor"></a><code><span class="keyword">module</span> <a href="Conv/index.html">Conv</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec module" id="module-Manip"><a href="#module-Manip" class="anchor"></a><code><span class="keyword">module</span> <a href="Manip/index.html">Manip</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide generic manipulation function of isla ast</p></dd></dl><dl><dt class="spec module" id="module-Preprocess"><a href="#module-Preprocess" class="anchor"></a><code><span class="keyword">module</span> <a href="Preprocess/index.html">Preprocess</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module is about preprocessing isla traces. This includes:</p></dd></dl><dl><dt class="spec module" id="module-Run"><a href="#module-Run" class="anchor"></a><code><span class="keyword">module</span> <a href="Run/index.html">Run</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide facility to run <a href="index.html"><code>Isla</code></a> trace over <a href="../State/index.html"><span>states</span></a></p></dd></dl><dl><dt class="spec module" id="module-Server"><a href="#module-Server" class="anchor"></a><code><span class="keyword">module</span> <a href="Server/index.html">Server</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module is about launching isla as a background server and using it</p></dd></dl><dl><dt class="spec module" id="module-Test"><a href="#module-Test" class="anchor"></a><code><span class="keyword">module</span> <a href="Test/index.html">Test</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This file about testing interaction with Isla for single instructions</p></dd></dl><dl><dt class="spec module" id="module-Type"><a href="#module-Type" class="anchor"></a><code><span class="keyword">module</span> <a href="Type/index.html">Type</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module is about type isla trace and register discovery.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Isla (read-dwarf.Isla)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Isla</nav><header class="odoc-preamble"><h1>Module <code><span>Isla</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="Base/index.html">Base</a> <span class="keyword">end</span></span></code></summary><h2 id="aliases"><a href="#aliases" class="anchor"></a>Aliases</h2><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Isla_lang</span>.AST <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-enum"><a href="#type-enum" class="anchor"></a><code><span><span class="keyword">type</span> enum</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lrng"><a href="#type-lrng" class="anchor"></a><code><span><span class="keyword">type</span> lrng</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.lrng</span><span> = </span></code><ol><li id="type-lrng.UnknownRng" class="def variant constructor anchored"><a href="#type-lrng.UnknownRng" class="anchor"></a><code><span>| </span><span><span class="constructor">UnknownRng</span></span></code></li><li id="type-lrng.Generated" class="def variant constructor anchored"><a href="#type-lrng.Generated" class="anchor"></a><code><span>| </span><span><span class="constructor">Generated</span> <span class="keyword">of</span> <a href="#type-lrng">lrng</a></span></code></li><li id="type-lrng.Range" class="def variant constructor anchored"><a href="#type-lrng.Range" class="anchor"></a><code><span>| </span><span><span class="constructor">Range</span> <span class="keyword">of</span> <span class="xref-unresolved">Stdlib</span>.Lexing.position * <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Parse_error_locn"><a href="#exception-Parse_error_locn" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Parse_error_locn</span> <span class="keyword">of</span> <a href="#type-lrng">lrng</a> * string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_lpos"><a href="#val-pp_lpos" class="anchor"></a><code><span><span class="keyword">val</span> pp_lpos : <span><span class="xref-unresolved">Stdlib</span>.Lexing.position <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_lrng"><a href="#val-pp_lrng" class="anchor"></a><code><span><span class="keyword">val</span> pp_lrng : <span><a href="#type-lrng">lrng</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-accessor"><a href="#type-accessor" class="anchor"></a><code><span><span class="keyword">type</span> accessor</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.accessor</span><span> = </span></code><ol><li id="type-accessor.Field" class="def variant constructor anchored"><a href="#type-accessor.Field" class="anchor"></a><code><span>| </span><span><span class="constructor">Field</span> <span class="keyword">of</span> string</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvarith"><a href="#type-bvarith" class="anchor"></a><code><span><span class="keyword">type</span> bvarith</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.bvarith</span><span> = </span></code><ol><li id="type-bvarith.Bvnand" class="def variant constructor anchored"><a href="#type-bvarith.Bvnand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnand</span></span></code></li><li id="type-bvarith.Bvnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnor</span></span></code></li><li id="type-bvarith.Bvxnor" class="def variant constructor anchored"><a href="#type-bvarith.Bvxnor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxnor</span></span></code></li><li id="type-bvarith.Bvsub" class="def variant constructor anchored"><a href="#type-bvarith.Bvsub" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsub</span></span></code></li><li id="type-bvarith.Bvudiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvudiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudiv</span></span></code></li><li id="type-bvarith.Bvudivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvudivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvudivi</span></span></code></li><li id="type-bvarith.Bvsdiv" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdiv" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdiv</span></span></code></li><li id="type-bvarith.Bvsdivi" class="def variant constructor anchored"><a href="#type-bvarith.Bvsdivi" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsdivi</span></span></code></li><li id="type-bvarith.Bvurem" class="def variant constructor anchored"><a href="#type-bvarith.Bvurem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvurem</span></span></code></li><li id="type-bvarith.Bvsrem" class="def variant constructor anchored"><a href="#type-bvarith.Bvsrem" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsrem</span></span></code></li><li id="type-bvarith.Bvsmod" class="def variant constructor anchored"><a href="#type-bvarith.Bvsmod" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsmod</span></span></code></li><li id="type-bvarith.Bvshl" class="def variant constructor anchored"><a href="#type-bvarith.Bvshl" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvshl</span></span></code></li><li id="type-bvarith.Bvlshr" class="def variant constructor anchored"><a href="#type-bvarith.Bvlshr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvlshr</span></span></code></li><li id="type-bvarith.Bvashr" class="def variant constructor anchored"><a href="#type-bvarith.Bvashr" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvashr</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvcomp"><a href="#type-bvcomp" class="anchor"></a><code><span><span class="keyword">type</span> bvcomp</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.bvcomp</span><span> = </span></code><ol><li id="type-bvcomp.Bvult" class="def variant constructor anchored"><a href="#type-bvcomp.Bvult" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvult</span></span></code></li><li id="type-bvcomp.Bvslt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvslt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvslt</span></span></code></li><li id="type-bvcomp.Bvule" class="def variant constructor anchored"><a href="#type-bvcomp.Bvule" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvule</span></span></code></li><li id="type-bvcomp.Bvsle" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsle" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsle</span></span></code></li><li id="type-bvcomp.Bvuge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvuge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvuge</span></span></code></li><li id="type-bvcomp.Bvsge" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsge" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsge</span></span></code></li><li id="type-bvcomp.Bvugt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvugt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvugt</span></span></code></li><li id="type-bvcomp.Bvsgt" class="def variant constructor anchored"><a href="#type-bvcomp.Bvsgt" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvsgt</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-bvmanyarith"><a href="#type-bvmanyarith" class="anchor"></a><code><span><span class="keyword">type</span> bvmanyarith</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.bvmanyarith</span><span> = </span></code><ol><li id="type-bvmanyarith.Bvand" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvand</span></span></code></li><li id="type-bvmanyarith.Bvor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvor</span></span></code></li><li id="type-bvmanyarith.Bvxor" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvxor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvxor</span></span></code></li><li id="type-bvmanyarith.Bvadd" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvadd" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvadd</span></span></code></li><li id="type-bvmanyarith.Bvmul" class="def variant constructor anchored"><a href="#type-bvmanyarith.Bvmul" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmul</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-accessor_list"><a href="#type-accessor_list" class="anchor"></a><code><span><span class="keyword">type</span> accessor_list</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.accessor_list</span><span> = </span></code><ol><li id="type-accessor_list.Nil" class="def variant constructor anchored"><a href="#type-accessor_list.Nil" class="anchor"></a><code><span>| </span><span><span class="constructor">Nil</span></span></code></li><li id="type-accessor_list.Cons" class="def variant constructor anchored"><a href="#type-accessor_list.Cons" class="anchor"></a><code><span>| </span><span><span class="constructor">Cons</span> <span class="keyword">of</span> <span><a href="#type-accessor">accessor</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-unop"><a href="#type-unop" class="anchor"></a><code><span><span class="keyword">type</span> unop</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.unop</span><span> = </span></code><ol><li id="type-unop.Not" class="def variant constructor anchored"><a href="#type-unop.Not" class="anchor"></a><code><span>| </span><span><span class="constructor">Not</span></span></code></li><li id="type-unop.Bvnot" class="def variant constructor anchored"><a href="#type-unop.Bvnot" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvnot</span></span></code></li><li id="type-unop.Bvredand" class="def variant constructor anchored"><a href="#type-unop.Bvredand" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredand</span></span></code></li><li id="type-unop.Bvredor" class="def variant constructor anchored"><a href="#type-unop.Bvredor" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvredor</span></span></code></li><li id="type-unop.Bvneg" class="def variant constructor anchored"><a href="#type-unop.Bvneg" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvneg</span></span></code></li><li id="type-unop.Extract" class="def variant constructor anchored"><a href="#type-unop.Extract" class="anchor"></a><code><span>| </span><span><span class="constructor">Extract</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-unop.ZeroExtend" class="def variant constructor anchored"><a href="#type-unop.ZeroExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">ZeroExtend</span> <span class="keyword">of</span> int</span></code></li><li id="type-unop.SignExtend" class="def variant constructor anchored"><a href="#type-unop.SignExtend" class="anchor"></a><code><span>| </span><span><span class="constructor">SignExtend</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-binop"><a href="#type-binop" class="anchor"></a><code><span><span class="keyword">type</span> binop</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.binop</span><span> = </span></code><ol><li id="type-binop.Eq" class="def variant constructor anchored"><a href="#type-binop.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span></span></code></li><li id="type-binop.Bvarith" class="def variant constructor anchored"><a href="#type-binop.Bvarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvarith</span> <span class="keyword">of</span> <a href="#type-bvarith">bvarith</a></span></code></li><li id="type-binop.Bvcomp" class="def variant constructor anchored"><a href="#type-binop.Bvcomp" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvcomp</span> <span class="keyword">of</span> <a href="#type-bvcomp">bvcomp</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-manyop"><a href="#type-manyop" class="anchor"></a><code><span><span class="keyword">type</span> manyop</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.manyop</span><span> = </span></code><ol><li id="type-manyop.And" class="def variant constructor anchored"><a href="#type-manyop.And" class="anchor"></a><code><span>| </span><span><span class="constructor">And</span></span></code></li><li id="type-manyop.Or" class="def variant constructor anchored"><a href="#type-manyop.Or" class="anchor"></a><code><span>| </span><span><span class="constructor">Or</span></span></code></li><li id="type-manyop.Bvmanyarith" class="def variant constructor anchored"><a href="#type-manyop.Bvmanyarith" class="anchor"></a><code><span>| </span><span><span class="constructor">Bvmanyarith</span> <span class="keyword">of</span> <a href="#type-bvmanyarith">bvmanyarith</a></span></code></li><li id="type-manyop.Concat" class="def variant constructor anchored"><a href="#type-manyop.Concat" class="anchor"></a><code><span>| </span><span><span class="constructor">Concat</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-base_val"><a href="#type-base_val" class="anchor"></a><code><span><span class="keyword">type</span> base_val</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.base_val</span><span> = </span></code><ol><li id="type-base_val.Val_Symbolic" class="def variant constructor anchored"><a href="#type-base_val.Val_Symbolic" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Symbolic</span> <span class="keyword">of</span> int</span></code></li><li id="type-base_val.Val_Bool" class="def variant constructor anchored"><a href="#type-base_val.Val_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Bool</span> <span class="keyword">of</span> bool</span></code></li><li id="type-base_val.Val_Bits" class="def variant constructor anchored"><a href="#type-base_val.Val_Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Bits</span> <span class="keyword">of</span> string</span></code></li><li id="type-base_val.Val_Enum" class="def variant constructor anchored"><a href="#type-base_val.Val_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Val_Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-assume_val"><a href="#type-assume_val" class="anchor"></a><code><span><span class="keyword">type</span> assume_val</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.assume_val</span><span> = </span></code><ol><li id="type-assume_val.AVal_Var" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Var" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Var</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a></span></code></li><li id="type-assume_val.AVal_Bool" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Bool</span> <span class="keyword">of</span> bool</span></code></li><li id="type-assume_val.AVal_Bits" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Bits" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Bits</span> <span class="keyword">of</span> string</span></code></li><li id="type-assume_val.AVal_Enum" class="def variant constructor anchored"><a href="#type-assume_val.AVal_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">AVal_Enum</span> <span class="keyword">of</span> <a href="#type-enum">enum</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> ty</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.ty</span><span> = </span></code><ol><li id="type-ty.Ty_Bool" class="def variant constructor anchored"><a href="#type-ty.Ty_Bool" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Bool</span></span></code></li><li id="type-ty.Ty_BitVec" class="def variant constructor anchored"><a href="#type-ty.Ty_BitVec" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_BitVec</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Enum" class="def variant constructor anchored"><a href="#type-ty.Ty_Enum" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Enum</span> <span class="keyword">of</span> int</span></code></li><li id="type-ty.Ty_Array" class="def variant constructor anchored"><a href="#type-ty.Ty_Array" class="anchor"></a><code><span>| </span><span><span class="constructor">Ty_Array</span> <span class="keyword">of</span> <a href="#type-ty">ty</a> * <a href="#type-ty">ty</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a exp</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.exp</span></span><span> = </span></code><ol><li id="type-exp.Val" class="def variant constructor anchored"><a href="#type-exp.Val" class="anchor"></a><code><span>| </span><span><span class="constructor">Val</span> <span class="keyword">of</span> <a href="#type-base_val">base_val</a> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Unop" class="def variant constructor anchored"><a href="#type-exp.Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Binop" class="def variant constructor anchored"><a href="#type-exp.Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">Binop</span> <span class="keyword">of</span> <a href="#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Manyop" class="def variant constructor anchored"><a href="#type-exp.Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-exp.Ite" class="def variant constructor anchored"><a href="#type-exp.Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-valu"><a href="#type-valu" class="anchor"></a><code><span><span class="keyword">type</span> valu</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.valu</span><span> = </span></code><ol><li id="type-valu.RegVal_Base" class="def variant constructor anchored"><a href="#type-valu.RegVal_Base" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Base</span> <span class="keyword">of</span> <a href="#type-base_val">base_val</a></span></code></li><li id="type-valu.RegVal_I" class="def variant constructor anchored"><a href="#type-valu.RegVal_I" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_I</span> <span class="keyword">of</span> int * int</span></code></li><li id="type-valu.RegVal_String" class="def variant constructor anchored"><a href="#type-valu.RegVal_String" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_String</span> <span class="keyword">of</span> string</span></code></li><li id="type-valu.RegVal_Unit" class="def variant constructor anchored"><a href="#type-valu.RegVal_Unit" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Unit</span></span></code></li><li id="type-valu.RegVal_Vector" class="def variant constructor anchored"><a href="#type-valu.RegVal_Vector" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Vector</span> <span class="keyword">of</span> <span><a href="#type-valu">valu</a> list</span></span></code></li><li id="type-valu.RegVal_List" class="def variant constructor anchored"><a href="#type-valu.RegVal_List" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_List</span> <span class="keyword">of</span> <span><a href="#type-valu">valu</a> list</span></span></code></li><li id="type-valu.RegVal_Struct" class="def variant constructor anchored"><a href="#type-valu.RegVal_Struct" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Struct</span> <span class="keyword">of</span> <span><span>(string * <a href="#type-valu">valu</a>)</span> list</span></span></code></li><li id="type-valu.RegVal_Constructor" class="def variant constructor anchored"><a href="#type-valu.RegVal_Constructor" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Constructor</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a></span></code></li><li id="type-valu.RegVal_Poison" class="def variant constructor anchored"><a href="#type-valu.RegVal_Poison" class="anchor"></a><code><span>| </span><span><span class="constructor">RegVal_Poison</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-a_exp"><a href="#type-a_exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a a_exp</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.a_exp</span></span><span> = </span></code><ol><li id="type-a_exp.AExp_Val" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Val" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Val</span> <span class="keyword">of</span> <a href="#type-assume_val">assume_val</a> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Unop" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Unop" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Unop</span> <span class="keyword">of</span> <a href="#type-unop">unop</a> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Binop" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Binop" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Binop</span> <span class="keyword">of</span> <a href="#type-binop">binop</a> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Manyop" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Manyop" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Manyop</span> <span class="keyword">of</span> <a href="#type-manyop">manyop</a> * <span><span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> list</span> * <span class="type-var">'a</span></span></code></li><li id="type-a_exp.AExp_Ite" class="def variant constructor anchored"><a href="#type-a_exp.AExp_Ite" class="anchor"></a><code><span>| </span><span><span class="constructor">AExp_Ite</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-smt"><a href="#type-smt" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a smt</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.smt</span></span><span> = </span></code><ol><li id="type-smt.DeclareConst" class="def variant constructor anchored"><a href="#type-smt.DeclareConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DeclareConst</span> <span class="keyword">of</span> int * <a href="#type-ty">ty</a></span></code></li><li id="type-smt.DefineConst" class="def variant constructor anchored"><a href="#type-smt.DefineConst" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineConst</span> <span class="keyword">of</span> int * <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.Assert" class="def variant constructor anchored"><a href="#type-smt.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span></span></code></li><li id="type-smt.DefineEnum" class="def variant constructor anchored"><a href="#type-smt.DefineEnum" class="anchor"></a><code><span>| </span><span><span class="constructor">DefineEnum</span> <span class="keyword">of</span> int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-arg_list"><a href="#type-arg_list" class="anchor"></a><code><span><span class="keyword">type</span> arg_list</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.arg_list</span><span> = </span></code><ol><li id="type-arg_list.NilArgs" class="def variant constructor anchored"><a href="#type-arg_list.NilArgs" class="anchor"></a><code><span>| </span><span><span class="constructor">NilArgs</span></span></code></li><li id="type-arg_list.ListArgs" class="def variant constructor anchored"><a href="#type-arg_list.ListArgs" class="anchor"></a><code><span>| </span><span><span class="constructor">ListArgs</span> <span class="keyword">of</span> <span><a href="#type-valu">valu</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tag_value"><a href="#type-tag_value" class="anchor"></a><code><span><span class="keyword">type</span> tag_value</span><span> = <span><a href="#type-valu">valu</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-segment"><a href="#type-segment" class="anchor"></a><code><span><span class="keyword">type</span> segment</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.segment</span><span> = </span></code><ol><li id="type-segment.Segment" class="def variant constructor anchored"><a href="#type-segment.Segment" class="anchor"></a><code><span>| </span><span><span class="constructor">Segment</span> <span class="keyword">of</span> string * int * int</span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-event"><a href="#type-event" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a event</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.event</span></span><span> = </span></code><ol><li id="type-event.Smt" class="def variant constructor anchored"><a href="#type-event.Smt" class="anchor"></a><code><span>| </span><span><span class="constructor">Smt</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-smt">smt</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-event.Branch" class="def variant constructor anchored"><a href="#type-event.Branch" class="anchor"></a><code><span>| </span><span><span class="constructor">Branch</span> <span class="keyword">of</span> int * string * <span class="type-var">'a</span></span></code></li><li id="type-event.ReadReg" class="def variant constructor anchored"><a href="#type-event.ReadReg" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadReg</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.WriteReg" class="def variant constructor anchored"><a href="#type-event.WriteReg" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteReg</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.ReadMem" class="def variant constructor anchored"><a href="#type-event.ReadMem" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadMem</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * int * <a href="#type-tag_value">tag_value</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.WriteMem" class="def variant constructor anchored"><a href="#type-event.WriteMem" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteMem</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * int * <a href="#type-tag_value">tag_value</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.BranchAddress" class="def variant constructor anchored"><a href="#type-event.BranchAddress" class="anchor"></a><code><span>| </span><span><span class="constructor">BranchAddress</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.Barrier" class="def variant constructor anchored"><a href="#type-event.Barrier" class="anchor"></a><code><span>| </span><span><span class="constructor">Barrier</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.CacheOp" class="def variant constructor anchored"><a href="#type-event.CacheOp" class="anchor"></a><code><span>| </span><span><span class="constructor">CacheOp</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.MarkReg" class="def variant constructor anchored"><a href="#type-event.MarkReg" class="anchor"></a><code><span>| </span><span><span class="constructor">MarkReg</span> <span class="keyword">of</span> string * string * <span class="type-var">'a</span></span></code></li><li id="type-event.Cycle" class="def variant constructor anchored"><a href="#type-event.Cycle" class="anchor"></a><code><span>| </span><span><span class="constructor">Cycle</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li><li id="type-event.Instr" class="def variant constructor anchored"><a href="#type-event.Instr" class="anchor"></a><code><span>| </span><span><span class="constructor">Instr</span> <span class="keyword">of</span> <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.Sleeping" class="def variant constructor anchored"><a href="#type-event.Sleeping" class="anchor"></a><code><span>| </span><span><span class="constructor">Sleeping</span> <span class="keyword">of</span> int * <span class="type-var">'a</span></span></code></li><li id="type-event.WakeRequest" class="def variant constructor anchored"><a href="#type-event.WakeRequest" class="anchor"></a><code><span>| </span><span><span class="constructor">WakeRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li><li id="type-event.SleepRequest" class="def variant constructor anchored"><a href="#type-event.SleepRequest" class="anchor"></a><code><span>| </span><span><span class="constructor">SleepRequest</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li><li id="type-event.AssumeReg" class="def variant constructor anchored"><a href="#type-event.AssumeReg" class="anchor"></a><code><span>| </span><span><span class="constructor">AssumeReg</span> <span class="keyword">of</span> string * <a href="#type-accessor_list">accessor_list</a> * <a href="#type-valu">valu</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.Assume" class="def variant constructor anchored"><a href="#type-event.Assume" class="anchor"></a><code><span>| </span><span><span class="constructor">Assume</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-a_exp">a_exp</a></span> * <span class="type-var">'a</span></span></code></li><li id="type-event.FunAssume" class="def variant constructor anchored"><a href="#type-event.FunAssume" class="anchor"></a><code><span>| </span><span><span class="constructor">FunAssume</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.UseFunAssume" class="def variant constructor anchored"><a href="#type-event.UseFunAssume" class="anchor"></a><code><span>| </span><span><span class="constructor">UseFunAssume</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.AbstractCall" class="def variant constructor anchored"><a href="#type-event.AbstractCall" class="anchor"></a><code><span>| </span><span><span class="constructor">AbstractCall</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li><li id="type-event.AbstractPrimop" class="def variant constructor anchored"><a href="#type-event.AbstractPrimop" class="anchor"></a><code><span>| </span><span><span class="constructor">AbstractPrimop</span> <span class="keyword">of</span> string * <a href="#type-valu">valu</a> * <a href="#type-arg_list">arg_list</a> * <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-instruction_segments"><a href="#type-instruction_segments" class="anchor"></a><code><span><span class="keyword">type</span> instruction_segments</span><span> = <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.instruction_segments</span><span> = </span></code><ol><li id="type-instruction_segments.Segments" class="def variant constructor anchored"><a href="#type-instruction_segments.Segments" class="anchor"></a><code><span>| </span><span><span class="constructor">Segments</span> <span class="keyword">of</span> <span><a href="#type-segment">segment</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trc"><a href="#type-trc" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a trc</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.trc</span></span><span> = </span></code><ol><li id="type-trc.Trace" class="def variant constructor anchored"><a href="#type-trc.Trace" class="anchor"></a><code><span>| </span><span><span class="constructor">Trace</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="#type-event">event</a></span> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-maybe_fork"><a href="#type-maybe_fork" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a maybe_fork</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.maybe_fork</span></span><span> = </span></code><ol><li id="type-maybe_fork.Cases" class="def variant constructor anchored"><a href="#type-maybe_fork.Cases" class="anchor"></a><code><span>| </span><span><span class="constructor">Cases</span> <span class="keyword">of</span> string * <span><span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span> list</span></span></code></li><li id="type-maybe_fork.End" class="def variant constructor anchored"><a href="#type-maybe_fork.End" class="anchor"></a><code><span>| </span><span><span class="constructor">End</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tree_trc"><a href="#type-tree_trc" class="anchor"></a><code><span><span class="keyword">and</span> <span>!'a tree_trc</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.tree_trc</span></span><span> = </span></code><ol><li id="type-tree_trc.TreeTrace" class="def variant constructor anchored"><a href="#type-tree_trc.TreeTrace" class="anchor"></a><code><span>| </span><span><span class="constructor">TreeTrace</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="#type-event">event</a></span> list</span> * <span><span class="type-var">'a</span> <a href="#type-maybe_fork">maybe_fork</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trcs"><a href="#type-trcs" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a trcs</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.trcs</span></span><span> = </span></code><ol><li id="type-trcs.Traces" class="def variant constructor anchored"><a href="#type-trcs.Traces" class="anchor"></a><code><span>| </span><span><span class="constructor">Traces</span> <span class="keyword">of</span> <span><span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span> list</span></span></code></li><li id="type-trcs.TracesWithSegments" class="def variant constructor anchored"><a href="#type-trcs.TracesWithSegments" class="anchor"></a><code><span>| </span><span><span class="constructor">TracesWithSegments</span> <span class="keyword">of</span> <a href="#type-instruction_segments">instruction_segments</a> * <span><span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-whole_tree"><a href="#type-whole_tree" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a whole_tree</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__Isla_lang_ast</span>.whole_tree</span></span><span> = </span></code><ol><li id="type-whole_tree.BareTree" class="def variant constructor anchored"><a href="#type-whole_tree.BareTree" class="anchor"></a><code><span>| </span><span><span class="constructor">BareTree</span> <span class="keyword">of</span> <span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span></span></code></li><li id="type-whole_tree.TreeWithSegments" class="def variant constructor anchored"><a href="#type-whole_tree.TreeWithSegments" class="anchor"></a><code><span>| </span><span><span class="constructor">TreeWithSegments</span> <span class="keyword">of</span> <a href="#type-instruction_segments">instruction_segments</a> * <span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_base_val"><a href="#val-subst_val_base_val" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_base_val : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-base_val">base_val</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_exp"><a href="#val-subst_val_exp" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_exp : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-exp">exp</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_valu"><a href="#val-subst_val_valu" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_valu : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-valu">valu</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-valu">valu</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_smt"><a href="#val-subst_val_smt" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_smt : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-smt">smt</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-smt">smt</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_arg_list"><a href="#val-subst_val_arg_list" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_arg_list : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-arg_list">arg_list</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-arg_list">arg_list</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_event"><a href="#val-subst_val_event" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_event : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-event">event</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-event">event</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_tree_trc"><a href="#val-subst_val_tree_trc" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_tree_trc : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-tree_trc">tree_trc</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_maybe_fork"><a href="#val-subst_val_maybe_fork" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_maybe_fork : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-maybe_fork">maybe_fork</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-maybe_fork">maybe_fork</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_trc"><a href="#val-subst_val_trc" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_trc : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-trc">trc</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_whole_tree"><a href="#val-subst_val_whole_tree" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_whole_tree : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-whole_tree">whole_tree</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-whole_tree">whole_tree</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-subst_val_trcs"><a href="#val-subst_val_trcs" class="anchor"></a><code><span><span class="keyword">val</span> subst_val_trcs : <span><a href="#type-base_val">base_val</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-trcs">trcs</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-trcs">trcs</a></span></span></code></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Lexer"><a href="#module-Lexer" class="anchor"></a><code><span><span class="keyword">module</span> Lexer</span><span> = <a href="Base/Lexer/index.html">Base.Lexer</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Parser"><a href="#module-Parser" class="anchor"></a><code><span><span class="keyword">module</span> Parser</span><span> = <a href="Base/Parser/index.html">Base.Parser</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-loc"><a href="#type-loc" class="anchor"></a><code><span><span class="keyword">type</span> loc</span><span> = <span class="xref-unresolved">Stdlib</span>.Lexing.position</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rtrc"><a href="#type-rtrc" class="anchor"></a><code><span><span class="keyword">type</span> rtrc</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-trc">trc</a></span></span></code></div><div class="spec-doc"><p>The type of raw traces out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-revent"><a href="#type-revent" class="anchor"></a><code><span><span class="keyword">type</span> revent</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-event">event</a></span></span></code></div><div class="spec-doc"><p>The type of raw events out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rsmt"><a href="#type-rsmt" class="anchor"></a><code><span><span class="keyword">type</span> rsmt</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-smt">smt</a></span></span></code></div><div class="spec-doc"><p>The type of raw SMT declaration out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rexp"><a href="#type-rexp" class="anchor"></a><code><span><span class="keyword">type</span> rexp</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-exp">exp</a></span></span></code></div><div class="spec-doc"><p>The type of raw expressions out of the parser</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rtrcs"><a href="#type-rtrcs" class="anchor"></a><code><span><span class="keyword">type</span> rtrcs</span><span> = <span><a href="#type-lrng">lrng</a> <a href="#type-trcs">trcs</a></span></span></code></div></div><h2 id="islatrace-parsing"><a href="#islatrace-parsing" class="anchor"></a>IslaTrace parsing</h2><div class="odoc-spec"><div class="spec exception anchored" id="exception-ParseError"><a href="#exception-ParseError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">ParseError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla parsing error</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-LexError"><a href="#exception-LexError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">LexError</span> <span class="keyword">of</span> <a href="#type-loc">loc</a> * string</span></code></div><div class="spec-doc"><p>Exception that represent an Isla lexing error</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-lexer"><a href="#type-lexer" class="anchor"></a><code><span><span class="keyword">type</span> lexer</span><span> = <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Parser</span>.token</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-parser"><a href="#type-parser" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a parser</span></span><span> = <span><a href="#type-lexer">lexer</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse"><a href="#val-parse" class="anchor"></a><code><span><span class="keyword">val</span> parse : <span><span><span class="type-var">'a</span> <a href="#type-parser">parser</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Parse a single Isla instruction output from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp"><a href="#val-parse_exp" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-rexp">rexp</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_string"><a href="#val-parse_exp_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-rexp">rexp</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_exp_channel"><a href="#val-parse_exp_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_exp_channel : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-rexp">rexp</a></span></code></div><div class="spec-doc"><p>Parse a single Isla expression from a channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trc"><a href="#val-parse_trc" class="anchor"></a><code><span><span class="keyword">val</span> parse_trc : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrc">rtrc</a></span></code></div><div class="spec-doc"><p>Parse an Isla trace from a Lexing.lexbuf</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trc_string"><a href="#val-parse_trc_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_trc_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrc">rtrc</a></span></code></div><div class="spec-doc"><p>Parse an Isla trace from a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trc_channel"><a href="#val-parse_trc_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_trc_channel : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrc">rtrc</a></span></code></div><div class="spec-doc"><p>Parse an Isla trace from a channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trcs"><a href="#val-parse_trcs" class="anchor"></a><code><span><span class="keyword">val</span> parse_trcs : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.lrng <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trcs</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trcs_string"><a href="#val-parse_trcs_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_trcs_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrcs">rtrcs</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_trcs_channel"><a href="#val-parse_trcs_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_trcs_channel : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-rtrcs">rtrcs</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_segments"><a href="#val-parse_segments" class="anchor"></a><code><span><span class="keyword">val</span> parse_segments : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.Lexing.lexbuf <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-instruction_segments">instruction_segments</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_segments_string"><a href="#val-parse_segments_string" class="anchor"></a><code><span><span class="keyword">val</span> parse_segments_string : <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-instruction_segments">instruction_segments</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parse_segments_channel"><a href="#val-parse_segments_channel" class="anchor"></a><code><span><span class="keyword">val</span> parse_segments_channel : 
+  <span><span class="optlabel">?filename</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-instruction_segments">instruction_segments</a></span></code></div></div><h2 id="islatrace-pretty-printing"><a href="#islatrace-pretty-printing" class="anchor"></a>IslaTrace pretty printing</h2><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Isla_lang</span>.PP <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_vvar"><a href="#val-pp_raw_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_name"><a href="#val-pp_raw_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum_ty"><a href="#val-pp_raw_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_enum"><a href="#val-pp_raw_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_enum : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.enum <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_nat"><a href="#val-pp_raw_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvi"><a href="#val-pp_raw_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bv"><a href="#val-pp_raw_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_str"><a href="#val-pp_raw_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_int"><a href="#val-pp_raw_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_ty"><a href="#val-pp_raw_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_ty : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.ty <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bool"><a href="#val-pp_raw_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_unop"><a href="#val-pp_raw_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_unop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.unop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvarith"><a href="#val-pp_raw_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvarith : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvarith <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvcomp"><a href="#val-pp_raw_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvcomp : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvcomp <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_binop"><a href="#val-pp_raw_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_binop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.binop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_bvmanyarith"><a href="#val-pp_raw_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_bvmanyarith : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvmanyarith <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_manyop"><a href="#val-pp_raw_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_manyop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.manyop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_base_val"><a href="#val-pp_raw_base_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_base_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.base_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_assume_val"><a href="#val-pp_raw_assume_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_assume_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.assume_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_exp"><a href="#val-pp_raw_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_a_exp"><a href="#val-pp_raw_a_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_a_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.a_exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_smt"><a href="#val-pp_raw_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_smt : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.smt</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_valu"><a href="#val-pp_raw_valu" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_valu : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_selem"><a href="#val-pp_raw_selem" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_selem : <span><span>(string * <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_accessor"><a href="#val-pp_raw_accessor" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_accessor : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_accessor_list"><a href="#val-pp_raw_accessor_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_accessor_list : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor_list <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_arg_list"><a href="#val-pp_raw_arg_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_arg_list : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.arg_list <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_tag_value"><a href="#val-pp_raw_tag_value" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_tag_value : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tag_value <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_event"><a href="#val-pp_raw_event" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_event : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.event</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_segment"><a href="#val-pp_raw_segment" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_segment : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.segment <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_instruction_segments"><a href="#val-pp_raw_instruction_segments" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_instruction_segments : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.instruction_segments <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_trc"><a href="#val-pp_raw_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_trcs"><a href="#val-pp_raw_trcs" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_trcs : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trcs</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_maybe_fork"><a href="#val-pp_raw_maybe_fork" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_maybe_fork : 
+  <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.maybe_fork</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_tree_trc"><a href="#val-pp_raw_tree_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_tree_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tree_trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw_whole_tree"><a href="#val-pp_raw_whole_tree" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw_whole_tree : 
+  <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.whole_tree</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_vvar"><a href="#val-pp_vvar" class="anchor"></a><code><span><span class="keyword">val</span> pp_vvar : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_name"><a href="#val-pp_name" class="anchor"></a><code><span><span class="keyword">val</span> pp_name : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum_ty"><a href="#val-pp_enum_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum_ty : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_enum"><a href="#val-pp_enum" class="anchor"></a><code><span><span class="keyword">val</span> pp_enum : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.enum <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_nat"><a href="#val-pp_nat" class="anchor"></a><code><span><span class="keyword">val</span> pp_nat : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvi"><a href="#val-pp_bvi" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvi : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bv"><a href="#val-pp_bv" class="anchor"></a><code><span><span class="keyword">val</span> pp_bv : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_str"><a href="#val-pp_str" class="anchor"></a><code><span><span class="keyword">val</span> pp_str : <span>string <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_j"><a href="#val-pp_j" class="anchor"></a><code><span><span class="keyword">val</span> pp_j : <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_int"><a href="#val-pp_int" class="anchor"></a><code><span><span class="keyword">val</span> pp_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_ty : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.ty <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bool"><a href="#val-pp_bool" class="anchor"></a><code><span><span class="keyword">val</span> pp_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_unop"><a href="#val-pp_unop" class="anchor"></a><code><span><span class="keyword">val</span> pp_unop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.unop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvarith"><a href="#val-pp_bvarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvarith : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvarith <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvcomp"><a href="#val-pp_bvcomp" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvcomp : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvcomp <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_binop"><a href="#val-pp_binop" class="anchor"></a><code><span><span class="keyword">val</span> pp_binop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.binop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bvmanyarith"><a href="#val-pp_bvmanyarith" class="anchor"></a><code><span><span class="keyword">val</span> pp_bvmanyarith : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.bvmanyarith <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_manyop"><a href="#val-pp_manyop" class="anchor"></a><code><span><span class="keyword">val</span> pp_manyop : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.manyop <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_base_val"><a href="#val-pp_base_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_base_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.base_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_assume_val"><a href="#val-pp_assume_val" class="anchor"></a><code><span><span class="keyword">val</span> pp_assume_val : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.assume_val <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_a_exp"><a href="#val-pp_a_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_a_exp : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.a_exp</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.smt</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_valu"><a href="#val-pp_valu" class="anchor"></a><code><span><span class="keyword">val</span> pp_valu : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_selem"><a href="#val-pp_selem" class="anchor"></a><code><span><span class="keyword">val</span> pp_selem : <span><span>(string * <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.valu)</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_accessor"><a href="#val-pp_accessor" class="anchor"></a><code><span><span class="keyword">val</span> pp_accessor : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_accessor_list"><a href="#val-pp_accessor_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_accessor_list : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.accessor_list <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_arg_list"><a href="#val-pp_arg_list" class="anchor"></a><code><span><span class="keyword">val</span> pp_arg_list : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.arg_list <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_tag_value"><a href="#val-pp_tag_value" class="anchor"></a><code><span><span class="keyword">val</span> pp_tag_value : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tag_value <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span><span class="keyword">val</span> pp_event : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.event</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_segment"><a href="#val-pp_segment" class="anchor"></a><code><span><span class="keyword">val</span> pp_segment : <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.segment <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_instruction_segments"><a href="#val-pp_instruction_segments" class="anchor"></a><code><span><span class="keyword">val</span> pp_instruction_segments : 
+  <span><span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.instruction_segments <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_trc"><a href="#val-pp_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_trcs"><a href="#val-pp_trcs" class="anchor"></a><code><span><span class="keyword">val</span> pp_trcs : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.trcs</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_maybe_fork"><a href="#val-pp_maybe_fork" class="anchor"></a><code><span><span class="keyword">val</span> pp_maybe_fork : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.maybe_fork</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_tree_trc"><a href="#val-pp_tree_trc" class="anchor"></a><code><span><span class="keyword">val</span> pp_tree_trc : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.tree_trc</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_whole_tree"><a href="#val-pp_whole_tree" class="anchor"></a><code><span><span class="keyword">val</span> pp_whole_tree : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Isla_lang__</span>.Isla_lang_ast.whole_tree</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div></div></details></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Base/index.html">Base</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module wraps all <code>isla-lang</code> functionality. No other module should directly touch the <code>Isla_lang</code> module.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cache/index.html">Cache</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a caching system for isla trace on top of <a href="Server/index.html"><code>Server</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Conv"><a href="#module-Conv" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Conv/index.html">Conv</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Manip"><a href="#module-Manip" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Manip/index.html">Manip</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide generic manipulation function of isla ast</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Preprocess"><a href="#module-Preprocess" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Preprocess/index.html">Preprocess</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is about preprocessing isla traces. This includes:</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Relocation"><a href="#module-Relocation" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Relocation/index.html">Relocation</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Run"><a href="#module-Run" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Run/index.html">Run</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide facility to run <a href="#"><code>Isla</code></a> trace over <a href="../State/index.html" title="State">states</a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Server"><a href="#module-Server" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Server/index.html">Server</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is about launching isla as a background server and using it</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Test"><a href="#module-Test" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Test/index.html">Test</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This file about testing interaction with Isla for single instructions</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Type"><a href="#module-Type" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Type/index.html">Type</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is about type isla trace and register discovery.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/CopySources/index.html b/doc/html/read-dwarf/Other_cmds/CopySources/index.html
index bd066247..5f816635 100644
--- a/doc/html/read-dwarf/Other_cmds/CopySources/index.html
+++ b/doc/html/read-dwarf/Other_cmds/CopySources/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CopySources (read-dwarf.Other_cmds.CopySources)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; CopySources</nav><h1>Module <code>Other_cmds.CopySources</code></h1></header><aside><p>This module is the body implementation for the <code>copy-sources</code> subcommand.</p></aside><dl><dt class="spec value" id="val-process_file"><a href="#val-process_file" class="anchor"></a><code><span class="keyword">val</span> process_file : unit <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CopySources (read-dwarf.Other_cmds.CopySources)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; CopySources</nav><header class="odoc-preamble"><h1>Module <code><span>Other_cmds.CopySources</span></code></h1><p>This module is the body implementation for the <code>copy-sources</code> subcommand.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-process_file"><a href="#val-process_file" class="anchor"></a><code><span><span class="keyword">val</span> process_file : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/CopySourcesCmd/index.html b/doc/html/read-dwarf/Other_cmds/CopySourcesCmd/index.html
index 37fd541a..3bab6499 100644
--- a/doc/html/read-dwarf/Other_cmds/CopySourcesCmd/index.html
+++ b/doc/html/read-dwarf/Other_cmds/CopySourcesCmd/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CopySourcesCmd (read-dwarf.Other_cmds.CopySourcesCmd)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; CopySourcesCmd</nav><h1>Module <code>Other_cmds.CopySourcesCmd</code></h1></header><aside><p>This module is the command-line processing for the <code>copy-sources</code> subcommand.</p></aside><dl><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-src_target_dir"><a href="#val-src_target_dir" class="anchor"></a><code><span class="keyword">val</span> src_target_dir : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-dry_run"><a href="#val-dry_run" class="anchor"></a><code><span class="keyword">val</span> dry_run : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-options"><a href="#val-options" class="anchor"></a><code><span class="keyword">val</span> options : <span><span>unit Cmdliner.Term.t</span> list</span></code></dt><dt class="spec value" id="val-full_term"><a href="#val-full_term" class="anchor"></a><code><span class="keyword">val</span> full_term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CopySourcesCmd (read-dwarf.Other_cmds.CopySourcesCmd)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; CopySourcesCmd</nav><header class="odoc-preamble"><h1>Module <code><span>Other_cmds.CopySourcesCmd</span></code></h1><p>This module is the command-line processing for the <code>copy-sources</code> subcommand.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-src_target_dir"><a href="#val-src_target_dir" class="anchor"></a><code><span><span class="keyword">val</span> src_target_dir : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dry_run"><a href="#val-dry_run" class="anchor"></a><code><span><span class="keyword">val</span> dry_run : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-options"><a href="#val-options" class="anchor"></a><code><span><span class="keyword">val</span> options : <span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-full_term"><a href="#val-full_term" class="anchor"></a><code><span><span class="keyword">val</span> full_term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/DumpDwarf/index.html b/doc/html/read-dwarf/Other_cmds/DumpDwarf/index.html
index 2112e126..8add435c 100644
--- a/doc/html/read-dwarf/Other_cmds/DumpDwarf/index.html
+++ b/doc/html/read-dwarf/Other_cmds/DumpDwarf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>DumpDwarf (read-dwarf.Other_cmds.DumpDwarf)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; DumpDwarf</nav><h1>Module <code>Other_cmds.DumpDwarf</code></h1></header><aside><p>This module adds a command to dump the interpreted DWARF information of an ELF file. The DWARF information is dumped as interpreted by read-dwarf,</p><p>See <a href="../ReadDwarf/index.html"><code>ReadDwarf</code></a> for a different dump/interpretation.</p></aside><dl><dt class="spec value" id="val-dump_dwarf"><a href="#val-dump_dwarf" class="anchor"></a><code><span class="keyword">val</span> dump_dwarf : string <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>DumpDwarf (read-dwarf.Other_cmds.DumpDwarf)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; DumpDwarf</nav><header class="odoc-preamble"><h1>Module <code><span>Other_cmds.DumpDwarf</span></code></h1><p>This module adds a command to dump the interpreted DWARF information of an ELF file. The DWARF information is dumped as interpreted by read-dwarf,</p><p>See <a href="../ReadDwarf/index.html"><code>ReadDwarf</code></a> for a different dump/interpretation.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-dump_dwarf"><a href="#val-dump_dwarf" class="anchor"></a><code><span><span class="keyword">val</span> dump_dwarf : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/DumpSym/index.html b/doc/html/read-dwarf/Other_cmds/DumpSym/index.html
index 57b2a542..58ab6c17 100644
--- a/doc/html/read-dwarf/Other_cmds/DumpSym/index.html
+++ b/doc/html/read-dwarf/Other_cmds/DumpSym/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>DumpSym (read-dwarf.Other_cmds.DumpSym)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; DumpSym</nav><h1>Module <code>Other_cmds.DumpSym</code></h1></header><aside><p>This module adds a command to dump the symbol of an ELF file with their content</p></aside><dl><dt class="spec value" id="val-dump_symbols"><a href="#val-dump_symbols" class="anchor"></a><code><span class="keyword">val</span> dump_symbols : string <span>&#45;&gt;</span> <span>string option</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-sym"><a href="#val-sym" class="anchor"></a><code><span class="keyword">val</span> sym : <span><span>string option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>DumpSym (read-dwarf.Other_cmds.DumpSym)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; DumpSym</nav><header class="odoc-preamble"><h1>Module <code><span>Other_cmds.DumpSym</span></code></h1><p>This module adds a command to dump the symbol of an ELF file with their content</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-dump_symbols"><a href="#val-dump_symbols" class="anchor"></a><code><span><span class="keyword">val</span> dump_symbols : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym"><a href="#val-sym" class="anchor"></a><code><span><span class="keyword">val</span> sym : <span><span>string option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/ReadDwarf/Default/index.html b/doc/html/read-dwarf/Other_cmds/ReadDwarf/Default/index.html
index 5a07519e..be6c7545 100644
--- a/doc/html/read-dwarf/Other_cmds/ReadDwarf/Default/index.html
+++ b/doc/html/read-dwarf/Other_cmds/ReadDwarf/Default/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Default (read-dwarf.Other_cmds.ReadDwarf.Default)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Other_cmds</a> &#x00BB; <a href="../index.html">ReadDwarf</a> &#x00BB; Default</nav><h1>Module <code>ReadDwarf.Default</code></h1></header><dl><dt class="spec value" id="val-action"><a href="#val-action" class="anchor"></a><code><span class="keyword">val</span> action : <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Default action to run when no command is set</p></dd></dl><dl><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dd><p>Global documentation string and name</p></dd></dl><dl><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt><dd><p>Default command</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Default (read-dwarf.Other_cmds.ReadDwarf.Default)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Other_cmds</a> &#x00BB; <a href="../index.html">ReadDwarf</a> &#x00BB; Default</nav><header class="odoc-preamble"><h1>Module <code><span>ReadDwarf.Default</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-action"><a href="#val-action" class="anchor"></a><code><span><span class="keyword">val</span> action : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Default action to run when no command is set</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div><div class="spec-doc"><p>Global documentation string and name</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div><div class="spec-doc"><p>Default command</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/ReadDwarf/index.html b/doc/html/read-dwarf/Other_cmds/ReadDwarf/index.html
index ab7e35c7..5a9baad2 100644
--- a/doc/html/read-dwarf/Other_cmds/ReadDwarf/index.html
+++ b/doc/html/read-dwarf/Other_cmds/ReadDwarf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ReadDwarf (read-dwarf.Other_cmds.ReadDwarf)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; ReadDwarf</nav><h1>Module <code>Other_cmds.ReadDwarf</code></h1></header><div class="spec module" id="module-Default"><a href="#module-Default" class="anchor"></a><code><span class="keyword">module</span> <a href="Default/index.html">Default</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-commands"><a href="#val-commands" class="anchor"></a><code><span class="keyword">val</span> commands : <span><span>(<span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info)</span> list</span></code></dt><dd><p>List of all non-default commands</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ReadDwarf (read-dwarf.Other_cmds.ReadDwarf)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Other_cmds</a> &#x00BB; ReadDwarf</nav><header class="odoc-preamble"><h1>Module <code><span>Other_cmds.ReadDwarf</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Default"><a href="#module-Default" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Default/index.html">Default</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-commands"><a href="#val-commands" class="anchor"></a><code><span><span class="keyword">val</span> commands : <span><span>(<span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info)</span> list</span></span></code></div><div class="spec-doc"><p>List of all non-default commands</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Other_cmds/index.html b/doc/html/read-dwarf/Other_cmds/index.html
index de32370d..4c465ba4 100644
--- a/doc/html/read-dwarf/Other_cmds/index.html
+++ b/doc/html/read-dwarf/Other_cmds/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Other_cmds (read-dwarf.Other_cmds)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Other_cmds</nav><h1>Module <code>Other_cmds</code></h1></header><dl><dt class="spec module" id="module-CopySources"><a href="#module-CopySources" class="anchor"></a><code><span class="keyword">module</span> <a href="CopySources/index.html">CopySources</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-CopySourcesCmd"><a href="#module-CopySourcesCmd" class="anchor"></a><code><span class="keyword">module</span> <a href="CopySourcesCmd/index.html">CopySourcesCmd</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-DumpDwarf"><a href="#module-DumpDwarf" class="anchor"></a><code><span class="keyword">module</span> <a href="DumpDwarf/index.html">DumpDwarf</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-DumpSym"><a href="#module-DumpSym" class="anchor"></a><code><span class="keyword">module</span> <a href="DumpSym/index.html">DumpSym</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-ReadDwarf"><a href="#module-ReadDwarf" class="anchor"></a><code><span class="keyword">module</span> <a href="ReadDwarf/index.html">ReadDwarf</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Other_cmds (read-dwarf.Other_cmds)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Other_cmds</nav><header class="odoc-preamble"><h1>Module <code><span>Other_cmds</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-CopySources"><a href="#module-CopySources" class="anchor"></a><code><span><span class="keyword">module</span> <a href="CopySources/index.html">CopySources</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is the body implementation for the <code>copy-sources</code> subcommand.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-CopySourcesCmd"><a href="#module-CopySourcesCmd" class="anchor"></a><code><span><span class="keyword">module</span> <a href="CopySourcesCmd/index.html">CopySourcesCmd</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is the command-line processing for the <code>copy-sources</code> subcommand.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-DumpDwarf"><a href="#module-DumpDwarf" class="anchor"></a><code><span><span class="keyword">module</span> <a href="DumpDwarf/index.html">DumpDwarf</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module adds a command to dump the interpreted DWARF information of an ELF file. The DWARF information is dumped as interpreted by read-dwarf,</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-DumpSym"><a href="#module-DumpSym" class="anchor"></a><code><span><span class="keyword">module</span> <a href="DumpSym/index.html">DumpSym</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module adds a command to dump the symbol of an ELF file with their content</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ReadDwarf"><a href="#module-ReadDwarf" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ReadDwarf/index.html">ReadDwarf</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Printing.html b/doc/html/read-dwarf/Printing.html
index dbf0cc36..a3a59a63 100644
--- a/doc/html/read-dwarf/Printing.html
+++ b/doc/html/read-dwarf/Printing.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Printing (read-dwarf.Printing)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; Printing</nav><h1 id="printing"><a href="#printing" class="anchor"></a>Printing</h1><nav class="toc"><ul><li><a href="#pretty-printing">Pretty printing</a></li><li><a href="#logging-system">Logging system</a></li></ul></nav></header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><p>Pretty printing is mostly done with the <code>pprint</code> library. This library is exposed by the <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> module with extra combinators. It should always be used by this <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> module.</p><h2 id="logging-system"><a href="#logging-system" class="anchor"></a>Logging system</h2><p>The logging system is defined in the module <a href="Utils/Logs/index.html"><code>Utils.Logs</code></a> and is the main way of signaling information like warnings to the user.</p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Printing (read-dwarf.Printing)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; Printing</nav><header class="odoc-preamble"><h1 id="printing"><a href="#printing" class="anchor"></a>Printing</h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#pretty-printing">Pretty printing</a></li><li><a href="#logging-system">Logging system</a></li></ul></nav></div><div class="odoc-content"><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><p>Pretty printing is mostly done with the <code>pprint</code> library. This library is exposed by the <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> module with extra combinators. It should always be used by this <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> module.</p><h2 id="logging-system"><a href="#logging-system" class="anchor"></a>Logging system</h2><p>The logging system is defined in the module <a href="Utils/Logs/index.html"><code>Utils.Logs</code></a> and is the main way of signaling information like warnings to the user.</p></div></body></html>
diff --git a/doc/html/read-dwarf/Qtest_isla/index.html b/doc/html/read-dwarf/Qtest_isla/index.html
index 7e5e5d1a..eb008fa2 100644
--- a/doc/html/read-dwarf/Qtest_isla/index.html
+++ b/doc/html/read-dwarf/Qtest_isla/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_isla (read-dwarf.Qtest_isla)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_isla</nav><h1>Module <code>Qtest_isla</code></h1></header></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_isla (read-dwarf.Qtest_isla)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_isla</nav><header class="odoc-preamble"><h1>Module <code><span>Qtest_isla</span></code></h1></header><div class="odoc-content"></div></body></html>
diff --git a/doc/html/read-dwarf/Qtest_run/index.html b/doc/html/read-dwarf/Qtest_run/index.html
index bd673ea0..d8938fe3 100644
--- a/doc/html/read-dwarf/Qtest_run/index.html
+++ b/doc/html/read-dwarf/Qtest_run/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_run (read-dwarf.Qtest_run)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_run</nav><h1>Module <code>Qtest_run</code></h1></header></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_run (read-dwarf.Qtest_run)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_run</nav><header class="odoc-preamble"><h1>Module <code><span>Qtest_run</span></code></h1></header><div class="odoc-content"></div></body></html>
diff --git a/doc/html/read-dwarf/Qtest_sig_aarch64/index.html b/doc/html/read-dwarf/Qtest_sig_aarch64/index.html
index e5eac1a3..1991be5c 100644
--- a/doc/html/read-dwarf/Qtest_sig_aarch64/index.html
+++ b/doc/html/read-dwarf/Qtest_sig_aarch64/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_sig_aarch64 (read-dwarf.Qtest_sig_aarch64)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_sig_aarch64</nav><h1>Module <code>Qtest_sig_aarch64</code></h1></header></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_sig_aarch64 (read-dwarf.Qtest_sig_aarch64)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_sig_aarch64</nav><header class="odoc-preamble"><h1>Module <code><span>Qtest_sig_aarch64</span></code></h1></header><div class="odoc-content"></div></body></html>
diff --git a/doc/html/read-dwarf/Qtest_utils/index.html b/doc/html/read-dwarf/Qtest_utils/index.html
index bd5ff1f7..e58e65a4 100644
--- a/doc/html/read-dwarf/Qtest_utils/index.html
+++ b/doc/html/read-dwarf/Qtest_utils/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_utils (read-dwarf.Qtest_utils)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_utils</nav><h1>Module <code>Qtest_utils</code></h1></header></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Qtest_utils (read-dwarf.Qtest_utils)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Qtest_utils</nav><header class="odoc-preamble"><h1>Module <code><span>Qtest_utils</span></code></h1></header><div class="odoc-content"></div></body></html>
diff --git a/doc/html/read-dwarf/Run/BB/index.html b/doc/html/read-dwarf/Run/BB/index.html
index 7ccd0561..fe32fb92 100644
--- a/doc/html/read-dwarf/Run/BB/index.html
+++ b/doc/html/read-dwarf/Run/BB/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BB (read-dwarf.Run.BB)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; BB</nav><h1>Module <code>Run.BB</code></h1></header><aside><p>This module allow to do a test run of all the machinery for a single basic block</p></aside><div class="spec module" id="module-SMT"><a href="#module-SMT" class="anchor"></a><code><span class="keyword">module</span> SMT = <a href="../../Z3/index.html">Z3</a></code></div><dl><dt class="spec value" id="val-dump"><a href="#val-dump" class="anchor"></a><code><span class="keyword">val</span> dump : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-reg_types"><a href="#val-reg_types" class="anchor"></a><code><span class="keyword">val</span> reg_types : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-no_run"><a href="#val-no_run" class="anchor"></a><code><span class="keyword">val</span> no_run : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_trace"><a href="#val-simp_trace" class="anchor"></a><code><span class="keyword">val</span> simp_trace : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_state"><a href="#val-simp_state" class="anchor"></a><code><span class="keyword">val</span> simp_state : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp"><a href="#val-simp" class="anchor"></a><code><span class="keyword">val</span> simp : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-sym"><a href="#val-sym" class="anchor"></a><code><span class="keyword">val</span> sym : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <span><span>int option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-get_code"><a href="#val-get_code" class="anchor"></a><code><span class="keyword">val</span> get_code : string <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>int option</span> <span>&#45;&gt;</span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></code></dt><dt class="spec value" id="val-code_term"><a href="#val-code_term" class="anchor"></a><code><span class="keyword">val</span> code_term : <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_trace_term"><a href="#val-simp_trace_term" class="anchor"></a><code><span class="keyword">val</span> simp_trace_term : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_state_term"><a href="#val-simp_state_term" class="anchor"></a><code><span class="keyword">val</span> simp_state_term : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-get_bb"><a href="#val-get_bb" class="anchor"></a><code><span class="keyword">val</span> get_bb : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <a href="../Bb_lib/index.html#type-t">Bb_lib.t</a></code></dt><dt class="spec value" id="val-bb_term"><a href="#val-bb_term" class="anchor"></a><code><span class="keyword">val</span> bb_term : <span><a href="../Bb_lib/index.html#type-t">Bb_lib.t</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-run_bb"><a href="#val-run_bb" class="anchor"></a><code><span class="keyword">val</span> run_bb : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="../Bb_lib/index.html#type-t">Bb_lib.t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BB (read-dwarf.Run.BB)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; BB</nav><header class="odoc-preamble"><h1>Module <code><span>Run.BB</span></code></h1><p>This module allow to do a test run of all the machinery for a single basic block</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-SMT"><a href="#module-SMT" class="anchor"></a><code><span><span class="keyword">module</span> SMT</span><span> = <a href="../../Z3/index.html">Z3</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dump"><a href="#val-dump" class="anchor"></a><code><span><span class="keyword">val</span> dump : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reg_types"><a href="#val-reg_types" class="anchor"></a><code><span><span class="keyword">val</span> reg_types : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-no_run"><a href="#val-no_run" class="anchor"></a><code><span><span class="keyword">val</span> no_run : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_trace"><a href="#val-simp_trace" class="anchor"></a><code><span><span class="keyword">val</span> simp_trace : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_state"><a href="#val-simp_state" class="anchor"></a><code><span><span class="keyword">val</span> simp_state : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp"><a href="#val-simp" class="anchor"></a><code><span><span class="keyword">val</span> simp : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sym"><a href="#val-sym" class="anchor"></a><code><span><span class="keyword">val</span> sym : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><span>int option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_code"><a href="#val-get_code" class="anchor"></a><code><span><span class="keyword">val</span> get_code : <span>string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>int option</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-code_term"><a href="#val-code_term" class="anchor"></a><code><span><span class="keyword">val</span> code_term : <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_trace_term"><a href="#val-simp_trace_term" class="anchor"></a><code><span><span class="keyword">val</span> simp_trace_term : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_state_term"><a href="#val-simp_state_term" class="anchor"></a><code><span><span class="keyword">val</span> simp_state_term : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_bb"><a href="#val-get_bb" class="anchor"></a><code><span><span class="keyword">val</span> get_bb : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Bb_lib/index.html#type-t">Bb_lib.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bb_term"><a href="#val-bb_term" class="anchor"></a><code><span><span class="keyword">val</span> bb_term : <span><a href="../Bb_lib/index.html#type-t">Bb_lib.t</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run_bb"><a href="#val-run_bb" class="anchor"></a><code><span><span class="keyword">val</span> run_bb : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="../Bb_lib/index.html#type-t">Bb_lib.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Bb_lib/index.html b/doc/html/read-dwarf/Run/Bb_lib/index.html
index bb988b63..1d7e088d 100644
--- a/doc/html/read-dwarf/Run/Bb_lib/index.html
+++ b/doc/html/read-dwarf/Run/Bb_lib/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Bb_lib (read-dwarf.Run.Bb_lib)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Bb_lib</nav><h1>Module <code>Run.Bb_lib</code></h1></header><aside><p>This module provide code to manipulate basic block and run them.</p><p>This is only for use by <a href="../BB/index.html"><code>BB</code></a> and debugging. I don't think this should be used for anything else. <a href="../Block/index.html"><code>Block</code></a> should generally be used instead.</p></aside><dl><dt class="spec type" id="type-trc"><a href="#type-trc" class="anchor"></a><code><span class="keyword">type</span> trc</code><code> = <a href="../../Trace/index.html#type-t">Trace.t</a></code></dt><dt class="spec type" id="type-state"><a href="#type-state" class="anchor"></a><code><span class="keyword">type</span> state</code><code> = <a href="../../State/index.html#type-t">State.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.main" class="anchored"><td class="def field"><a href="#type-t.main" class="anchor"></a><code>main : <span><a href="index.html#type-trc">trc</a> array</span>;</code></td></tr></table><code>}</code></dt><dd><p>Type of a basic block.</p><p>The main part is the traces of all the non-branching instruction</p></dd></dl><dl><dt class="spec value" id="val-from_binary"><a href="#val-from_binary" class="anchor"></a><code><span class="keyword">val</span> from_binary : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take a binary block and call isla on all the instruction to get traces Also does the typing of traces for register discovery. TODO Support variable length instructions</p></dd></dl><dl><dt class="spec value" id="val-simplify_mut"><a href="#val-simplify_mut" class="anchor"></a><code><span class="keyword">val</span> simplify_mut : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Simplifies the traces in the basic block</p></dd></dl><dl><dt class="spec value" id="val-run_mut"><a href="#val-run_mut" class="anchor"></a><code><span class="keyword">val</span> run_mut : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Run a linear basic block on a state by mutation.</p><p>If <code>dwarf</code> is provided, the run is typed.</p></dd></dl><dl><dt class="spec value" id="val-run"><a href="#val-run" class="anchor"></a><code><span class="keyword">val</span> run : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-state">state</a></code></dt><dd><p>Run a linear basic block on a trace and return a new state</p><p>If <code>dwarf</code> is provided, the run is typed.</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty print the basic block (The traces)</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Bb_lib (read-dwarf.Run.Bb_lib)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Bb_lib</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Bb_lib</span></code></h1><p>This module provide code to manipulate basic block and run them.</p><p>This is only for use by <a href="../BB/index.html"><code>BB</code></a> and debugging. I don't think this should be used for anything else. <a href="../Block/index.html"><code>Block</code></a> should generally be used instead.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-trc"><a href="#type-trc" class="anchor"></a><code><span><span class="keyword">type</span> trc</span><span> = <a href="../../Trace/index.html#type-t">Trace.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-state"><a href="#type-state" class="anchor"></a><code><span><span class="keyword">type</span> state</span><span> = <a href="../../State/index.html#type-t">State.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.main" class="def record field anchored"><a href="#type-t.main" class="anchor"></a><code><span>main : <span><a href="#type-trc">trc</a> array</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Type of a basic block.</p><p>The main part is the traces of all the non-branching instruction</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from_binary"><a href="#val-from_binary" class="anchor"></a><code><span><span class="keyword">val</span> from_binary : <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Take a binary block and call isla on all the instruction to get traces Also does the typing of traces for register discovery. TODO Support variable length instructions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_mut"><a href="#val-simplify_mut" class="anchor"></a><code><span><span class="keyword">val</span> simplify_mut : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Simplifies the traces in the basic block</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run_mut"><a href="#val-run_mut" class="anchor"></a><code><span><span class="keyword">val</span> run_mut : <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Run a linear basic block on a state by mutation.</p><p>If <code>dwarf</code> is provided, the run is typed.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run"><a href="#val-run" class="anchor"></a><code><span><span class="keyword">val</span> run : <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-state">state</a></span></code></div><div class="spec-doc"><p>Run a linear basic block on a trace and return a new state</p><p>If <code>dwarf</code> is provided, the run is typed.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the basic block (The traces)</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Block/index.html b/doc/html/read-dwarf/Run/Block/index.html
index daf6931c..c7a96824 100644
--- a/doc/html/read-dwarf/Run/Block/index.html
+++ b/doc/html/read-dwarf/Run/Block/index.html
@@ -1,2 +1,9 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Block (read-dwarf.Run.Block)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Block</nav><h1>Module <code>Run.Block</code></h1></header><aside><p>This module add the <code>run-block</code> sub command.</p><p>This subcommand is about running a complex block of execution It start at a specific offset in a block and can terminate on various condition. If not enough condition are met, it may crash by reaching an invalid instruction</p></aside><dl><dt class="spec value" id="val-no_run"><a href="#val-no_run" class="anchor"></a><code><span class="keyword">val</span> no_run : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-reg_types"><a href="#val-reg_types" class="anchor"></a><code><span class="keyword">val</span> reg_types : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <span><span>int option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-breakpoints"><a href="#val-breakpoints" class="anchor"></a><code><span class="keyword">val</span> breakpoints : <span><span>string list</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-ensure_linear"><a href="#val-ensure_linear" class="anchor"></a><code><span class="keyword">val</span> ensure_linear : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-get_elf_start"><a href="#val-get_elf_start" class="anchor"></a><code><span class="keyword">val</span> get_elf_start : string <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a></code></dt><dt class="spec value" id="val-elf_term"><a href="#val-elf_term" class="anchor"></a><code><span class="keyword">val</span> elf_term : <span><span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a>)</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-gen_block"><a href="#val-gen_block" class="anchor"></a><code><span class="keyword">val</span> gen_block : <span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a>)</span> <span>&#45;&gt;</span> <span>int option</span> <span>&#45;&gt;</span> <span>string list</span> <span>&#45;&gt;</span> <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../Block_lib/index.html#type-t">Block_lib.t</a></code></dt><dt class="spec value" id="val-elfblock_term"><a href="#val-elfblock_term" class="anchor"></a><code><span class="keyword">val</span> elfblock_term : <span><span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../Block_lib/index.html#type-t">Block_lib.t</a>)</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-prune_paths"><a href="#val-prune_paths" class="anchor"></a><code><span class="keyword">val</span> prune_paths : <span>(<a href="../../State/Base/index.html#type-t">State.Base.t</a> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span> option</span></code></dt><dt class="spec value" id="val-has_assert_false"><a href="#val-has_assert_false" class="anchor"></a><code><span class="keyword">val</span> has_assert_false : <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-run_block"><a href="#val-run_block" class="anchor"></a><code><span class="keyword">val</span> run_block : <span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../Block_lib/index.html#type-t">Block_lib.t</a>)</span> <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Block (read-dwarf.Run.Block)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Block</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Block</span></code></h1><p>This module add the <code>run-block</code> sub command.</p><p>This subcommand is about running a complex block of execution It start at a specific offset in a block and can terminate on various condition. If not enough condition are met, it may crash by reaching an invalid instruction</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-no_run"><a href="#val-no_run" class="anchor"></a><code><span><span class="keyword">val</span> no_run : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reg_types"><a href="#val-reg_types" class="anchor"></a><code><span><span class="keyword">val</span> reg_types : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><span>int option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-breakpoints"><a href="#val-breakpoints" class="anchor"></a><code><span><span class="keyword">val</span> breakpoints : <span><span>string list</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_linear"><a href="#val-ensure_linear" class="anchor"></a><code><span><span class="keyword">val</span> ensure_linear : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_elf_start"><a href="#val-get_elf_start" class="anchor"></a><code><span><span class="keyword">val</span> get_elf_start : <span>string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf_term"><a href="#val-elf_term" class="anchor"></a><code><span><span class="keyword">val</span> elf_term : <span><span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a>)</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-gen_block"><a href="#val-gen_block" class="anchor"></a><code><span><span class="keyword">val</span> gen_block : 
+  <span><span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../../Elf/SymTable/index.html#type-sym_offset">Elf.SymTable.sym_offset</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>int option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../Block_lib/index.html#type-t">Block_lib.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elfblock_term"><a href="#val-elfblock_term" class="anchor"></a><code><span><span class="keyword">val</span> elfblock_term : <span><span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../Block_lib/index.html#type-t">Block_lib.t</a>)</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prune_paths"><a href="#val-prune_paths" class="anchor"></a><code><span><span class="keyword">val</span> prune_paths : 
+  <span><span>(<span><a href="../../State/Base/index.html#type-t">State.Base.t</a> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-has_assert_false"><a href="#val-has_assert_false" class="anchor"></a><code><span><span class="keyword">val</span> has_assert_false : <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run_block"><a href="#val-run_block" class="anchor"></a><code><span><span class="keyword">val</span> run_block : <span><span>(<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> * <a href="../Block_lib/index.html#type-t">Block_lib.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Block_lib/index.html b/doc/html/read-dwarf/Run/Block_lib/index.html
index fbd8b7a9..1e07179b 100644
--- a/doc/html/read-dwarf/Run/Block_lib/index.html
+++ b/doc/html/read-dwarf/Run/Block_lib/index.html
@@ -1,2 +1,18 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Block_lib (read-dwarf.Run.Block_lib)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Block_lib</nav><h1>Module <code>Run.Block_lib</code></h1></header><aside><p>This module provides a representation of a complex block of code.</p><p>The end of the block is decided by <code>endpred</code>, an arbitrary predicate on the pc. In particular if the PC is symbolic the execution is stopped anyway. This means that we either reached the top level function return or an unresolved branch table.</p><p>To generate easily end predicates, there is <a href="index.html#val-gen_endpred"><code>gen_endpred</code></a>.</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.runner" class="anchored"><td class="def field"><a href="#type-t.runner" class="anchor"></a><code>runner : <a href="../Runner/index.html#type-t">Runner.t</a>;</code></td></tr><tr id="type-t.start" class="anchored"><td class="def field"><a href="#type-t.start" class="anchor"></a><code>start : int;</code></td></tr><tr id="type-t.endpred" class="anchored"><td class="def field"><a href="#type-t.endpred" class="anchor"></a><code>endpred : <a href="../../State/index.html#type-exp">State.exp</a> <span>&#45;&gt;</span> <span>string option</span>;</code></td></tr></table><code>}</code></dt><dd><p><code>endpred pc_exp</code> gives when to stop</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>runner:<a href="../Runner/index.html#type-t">Runner.t</a></span> <span>&#45;&gt;</span> <span>start:int</span> <span>&#45;&gt;</span> <span>endpred:<span>(<a href="../../State/index.html#type-exp">State.exp</a> <span>&#45;&gt;</span> <span>string option</span>)</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a complex block starting from <code>start</code> in <code>sym</code> and ending when <code>endpred</code> says so. <code>endpred</code> is a predicate on the symbolic PC expression</p></dd></dl><dl><dt class="spec type" id="type-label"><a href="#type-label" class="anchor"></a><code><span class="keyword">type</span> label</code><code> = </code><table class="variant"><tr id="type-label.Start" class="anchored"><td class="def constructor"><a href="#type-label.Start" class="anchor"></a><code>| </code><code><span class="constructor">Start</span></code></td><td class="doc"><p>Root node of the tree</p></td></tr><tr id="type-label.End" class="anchored"><td class="def constructor"><a href="#type-label.End" class="anchor"></a><code>| </code><code><span class="constructor">End</span> <span class="keyword">of</span> string</code></td><td class="doc"><p>Lead node of the tree, the string describe which end condition has be triggered</p></td></tr><tr id="type-label.BranchAt" class="anchored"><td class="def constructor"><a href="#type-label.BranchAt" class="anchor"></a><code>| </code><code><span class="constructor">BranchAt</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>A Branching node at a given PC</p></td></tr><tr id="type-label.NormalAt" class="anchored"><td class="def constructor"><a href="#type-label.NormalAt" class="anchor"></a><code>| </code><code><span class="constructor">NormalAt</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>A normal instruction at PC. Exists only if <code>every_instruction</code> is true</p></td></tr></table></dt><dd><p>The labels on tree node at the output of <a href="index.html#val-run"><code>run</code></a></p></dd></dl><dl><dt class="spec value" id="val-label_to_string"><a href="#val-label_to_string" class="anchor"></a><code><span class="keyword">val</span> label_to_string : <a href="index.html#type-label">label</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-pp_label"><a href="#val-pp_label" class="anchor"></a><code><span class="keyword">val</span> pp_label : <a href="index.html#type-label">label</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-run"><a href="#val-run" class="anchor"></a><code><span class="keyword">val</span> run : <span>?&#8288;every_instruction:bool</span> <span>&#45;&gt;</span> <span>?&#8288;relevant:<span><span>(int, <span class="type-var">'a</span>)</span> Stdlib.Hashtbl.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-label">label</a> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span></code></dt><dd><p>Run the block an return a state tree indexed by the addresses of the branches.</p><p>When <code>every_instruction</code> is true, It will make a snapshot of the state i.e a tree node at each instruction. By default it will only make a Tree node on branching points.</p><p>The output is a tree because state merging is not implemented so if we are going twice on the same PC, the whole thing will be run twice separately in two separate tree branches.</p></dd></dl><dl><dt class="spec value" id="val-gen_endpred"><a href="#val-gen_endpred" class="anchor"></a><code><span class="keyword">val</span> gen_endpred : <span>?&#8288;min:int</span> <span>&#45;&gt;</span> <span>?&#8288;max:int</span> <span>&#45;&gt;</span> <span>?&#8288;loop:int</span> <span>&#45;&gt;</span> <span>?&#8288;brks:<span>int list</span></span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> <a href="../../State/index.html#type-exp">State.exp</a> <span>&#45;&gt;</span> <span>string option</span></code></dt><dd><p>Generic end predicate. Will stop if:</p><ul><li>pc below <code>min</code></li><li>pc above <code>max</code></li><li>pc is one of <code>brks</code></li><li>pc has be seen more than <code>loop</code></li></ul></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Block_lib (read-dwarf.Run.Block_lib)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Block_lib</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Block_lib</span></code></h1><p>This module provides a representation of a complex block of code.</p><p>The end of the block is decided by <code>endpred</code>, an arbitrary predicate on the pc. In particular if the PC is symbolic the execution is stopped anyway. This means that we either reached the top level function return or an unresolved branch table.</p><p>To generate easily end predicates, there is <a href="#val-gen_endpred"><code>gen_endpred</code></a>.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.runner" class="def record field anchored"><a href="#type-t.runner" class="anchor"></a><code><span>runner : <a href="../Runner/index.html#type-t">Runner.t</a>;</span></code></li><li id="type-t.start" class="def record field anchored"><a href="#type-t.start" class="anchor"></a><code><span>start : <a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a>;</span></code></li><li id="type-t.endpred" class="def record field anchored"><a href="#type-t.endpred" class="anchor"></a><code><span>endpred : <span><a href="../../State/index.html#type-exp">State.exp</a> <span class="arrow">&#45;&gt;</span></span> <span>string option</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p><code>endpred pc_exp</code> gives when to stop</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : 
+  <span><span class="label">runner</span>:<a href="../Runner/index.html#type-t">Runner.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">start</span>:<a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">endpred</span>:<span>(<span><a href="../../State/index.html#type-exp">State.exp</a> <span class="arrow">&#45;&gt;</span></span> <span>string option</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a complex block starting from <code>start</code> in <code>sym</code> and ending when <code>endpred</code> says so. <code>endpred</code> is a predicate on the symbolic PC expression</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-label"><a href="#type-label" class="anchor"></a><code><span><span class="keyword">type</span> label</span><span> = </span></code><ol><li id="type-label.Start" class="def variant constructor anchored"><a href="#type-label.Start" class="anchor"></a><code><span>| </span><span><span class="constructor">Start</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Root node of the tree</p><span class="comment-delim">*)</span></div></li><li id="type-label.End" class="def variant constructor anchored"><a href="#type-label.End" class="anchor"></a><code><span>| </span><span><span class="constructor">End</span> <span class="keyword">of</span> string</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Lead node of the tree, the string describe which end condition has be triggered</p><span class="comment-delim">*)</span></div></li><li id="type-label.BranchAt" class="def variant constructor anchored"><a href="#type-label.BranchAt" class="anchor"></a><code><span>| </span><span><span class="constructor">BranchAt</span> <span class="keyword">of</span> <a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>A Branching node at a given PC</p><span class="comment-delim">*)</span></div></li><li id="type-label.NormalAt" class="def variant constructor anchored"><a href="#type-label.NormalAt" class="anchor"></a><code><span>| </span><span><span class="constructor">NormalAt</span> <span class="keyword">of</span> <a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>A normal instruction at PC. Exists only if <code>every_instruction</code> is true</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The labels on tree node at the output of <a href="#val-run"><code>run</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-label_to_string"><a href="#val-label_to_string" class="anchor"></a><code><span><span class="keyword">val</span> label_to_string : <span><a href="#type-label">label</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_label"><a href="#val-pp_label" class="anchor"></a><code><span><span class="keyword">val</span> pp_label : <span><a href="#type-label">label</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run"><a href="#val-run" class="anchor"></a><code><span><span class="keyword">val</span> run : 
+  <span><span class="optlabel">?every_instruction</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?relevant</span>:<span><span>(<a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a>, <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-label">label</a> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span></span></code></div><div class="spec-doc"><p>Run the block an return a state tree indexed by the addresses of the branches.</p><p>When <code>every_instruction</code> is true, It will make a snapshot of the state i.e a tree node at each instruction. By default it will only make a Tree node on branching points.</p><p>The output is a tree because state merging is not implemented so if we are going twice on the same PC, the whole thing will be run twice separately in two separate tree branches.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-gen_endpred"><a href="#val-gen_endpred" class="anchor"></a><code><span><span class="keyword">val</span> gen_endpred : 
+  <span><span class="optlabel">?min</span>:<a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?max</span>:<a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?loop</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?brks</span>:<span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span>unit <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-exp">State.exp</a> <span class="arrow">&#45;&gt;</span></span>
+  <span>string option</span></span></code></div><div class="spec-doc"><p>Generic end predicate. Will stop if:</p><ul><li>pc below <code>min</code></li><li>pc above <code>max</code></li><li>pc is one of <code>brks</code></li><li>pc has be seen more than <code>loop</code></li></ul></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Func/index.html b/doc/html/read-dwarf/Run/Func/index.html
index 91dccb8b..79caa5b3 100644
--- a/doc/html/read-dwarf/Run/Func/index.html
+++ b/doc/html/read-dwarf/Run/Func/index.html
@@ -1,2 +1,14 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Func (read-dwarf.Run.Func)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Func</nav><h1>Module <code>Run.Func</code></h1></header><dl><dt class="spec value" id="val-get_state_tree"><a href="#val-get_state_tree" class="anchor"></a><code><span class="keyword">val</span> get_state_tree : <span>elf:string</span> <span>&#45;&gt;</span> <span>name:string</span> <span>&#45;&gt;</span> <span>?&#8288;dump:bool</span> <span>&#45;&gt;</span> <span>?&#8288;entry:bool</span> <span>&#45;&gt;</span> <span>?&#8288;len:int</span> <span>&#45;&gt;</span> <span>?&#8288;breakpoints:<span>string list</span></span> <span>&#45;&gt;</span> <span>?&#8288;loop:int</span> <span>&#45;&gt;</span> <span>?&#8288;tree_to_file:string</span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> <span><a href="../Block_lib/index.html#type-label">Block_lib.label</a> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span></code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Func (read-dwarf.Run.Func)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Func</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Func</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-get_state_tree"><a href="#val-get_state_tree" class="anchor"></a><code><span><span class="keyword">val</span> get_state_tree : 
+  <span><span class="label">elf</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">name</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?dump</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?entry</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?len</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?breakpoints</span>:<span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?loop</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?tree_to_file</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?init</span>:<span>(<span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-t">State.t</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?every_instruction</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span>unit <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Block_lib/index.html#type-label">Block_lib.label</a> <a href="../../State/Tree/index.html#type-t">State.Tree.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/FuncRD/index.html b/doc/html/read-dwarf/Run/FuncRD/index.html
index 30f7c999..c4132dc6 100644
--- a/doc/html/read-dwarf/Run/FuncRD/index.html
+++ b/doc/html/read-dwarf/Run/FuncRD/index.html
@@ -1,2 +1,8 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>FuncRD (read-dwarf.Run.FuncRD)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; FuncRD</nav><h1>Module <code>Run.FuncRD</code></h1></header><aside><p>This module is a merge of <code>rd</code> sub command and <code>run-func --loop=1</code>. It will run the equivalent of <code>run-func --loop=1</code>, and print the instruction like <code>rd</code> but will print the state in a light form (<a href="../../State/index.html#val-pp_partial"><code>State.pp_partial</code></a>) between instructions.</p></aside><dl><dt class="spec value" id="val-run_func_rd"><a href="#val-run_func_rd" class="anchor"></a><code><span class="keyword">val</span> run_func_rd : string <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>string option</span> <span>&#45;&gt;</span> <span>string list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-func"><a href="#val-func" class="anchor"></a><code><span class="keyword">val</span> func : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-objdump_d"><a href="#val-objdump_d" class="anchor"></a><code><span class="keyword">val</span> objdump_d : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-branch_table"><a href="#val-branch_table" class="anchor"></a><code><span class="keyword">val</span> branch_table : <span><span>string option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-breakpoints"><a href="#val-breakpoints" class="anchor"></a><code><span class="keyword">val</span> breakpoints : <span><span>string list</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>FuncRD (read-dwarf.Run.FuncRD)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; FuncRD</nav><header class="odoc-preamble"><h1>Module <code><span>Run.FuncRD</span></code></h1><p>This module is a merge of <code>rd</code> sub command and <code>run-func --loop=1</code>. It will run the equivalent of <code>run-func --loop=1</code>, and print the instruction like <code>rd</code> but will print the state in a light form (<a href="../../State/index.html#val-pp_partial"><code>State.pp_partial</code></a>) between instructions.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-run_func_rd"><a href="#val-run_func_rd" class="anchor"></a><code><span><span class="keyword">val</span> run_func_rd : 
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span>string <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-func"><a href="#val-func" class="anchor"></a><code><span><span class="keyword">val</span> func : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-objdump_d"><a href="#val-objdump_d" class="anchor"></a><code><span><span class="keyword">val</span> objdump_d : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-branch_table"><a href="#val-branch_table" class="anchor"></a><code><span><span class="keyword">val</span> branch_table : <span><span>string option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-breakpoints"><a href="#val-breakpoints" class="anchor"></a><code><span><span class="keyword">val</span> breakpoints : <span><span>string list</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Init/index.html b/doc/html/read-dwarf/Run/Init/index.html
index 14d4ff3a..fb4c39fb 100644
--- a/doc/html/read-dwarf/Run/Init/index.html
+++ b/doc/html/read-dwarf/Run/Init/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Init (read-dwarf.Run.Init)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Init</nav><h1>Module <code>Run.Init</code></h1></header><aside><p>This module handle architecture initialization. For now it trust default isla initialization but this should change soon (TODO)</p></aside><dl><dt class="spec value" id="val-init_state"><a href="#val-init_state" class="anchor"></a><code><span class="keyword">val</span> init_state : <span><span><a href="../../State/index.html#type-t">State.t</a> option</span> Stdlib.ref</span></code></dt><dd><p>The initial state</p></dd></dl><dl><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : unit <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a></code></dt><dd><p>Intialize this module by calling Isla on <a href="../../Arch/index.html#val-nop"><code>Arch.nop</code></a> to get initial machine state</p></dd></dl><dl><dt class="spec value" id="val-state"><a href="#val-state" class="anchor"></a><code><span class="keyword">val</span> state : unit <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a></code></dt><dd><p>Return the initial state. Compute it if required.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Init (read-dwarf.Run.Init)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Init</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Init</span></code></h1><p>This module handle architecture initialization. For now it trust default isla initialization but this should change soon (TODO)</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-init_state"><a href="#val-init_state" class="anchor"></a><code><span><span class="keyword">val</span> init_state : <span><span><a href="../../State/index.html#type-t">State.t</a> option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>The initial state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-t">State.t</a></span></code></div><div class="spec-doc"><p>Intialize this module by calling Isla on <a href="../../Arch/index.html#val-nop"><code>Arch.nop</code></a> to get initial machine state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-state"><a href="#val-state" class="anchor"></a><code><span><span class="keyword">val</span> state : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-t">State.t</a></span></code></div><div class="spec-doc"><p>Return the initial state. Compute it if required.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Instr/index.html b/doc/html/read-dwarf/Run/Instr/index.html
index f41285f8..01eb8e60 100644
--- a/doc/html/read-dwarf/Run/Instr/index.html
+++ b/doc/html/read-dwarf/Run/Instr/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Instr (read-dwarf.Run.Instr)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Instr</nav><h1>Module <code>Run.Instr</code></h1></header><aside><p>This module add the <code>run-instr</code> sub command.</p><p>This subcommand is about testing the various operations that can happen in an instruction processing. This is not <code>isla-test</code>, the instructions will always be fetched from the cache and use <a href="../Init/index.html"><code>Init</code></a>. If this fail at an earlier point, use <code>isla-test</code> to debug the Isla pipeline</p><p>Additionally <code>run-instr</code> supports branching instructions.</p></aside><dl><dt class="spec type" id="type-traces"><a href="#type-traces" class="anchor"></a><code><span class="keyword">type</span> traces</code><code> = </code><table class="variant"><tr id="type-traces.IslaTraces" class="anchored"><td class="def constructor"><a href="#type-traces.IslaTraces" class="anchor"></a><code>| </code><code><span class="constructor">IslaTraces</span> <span class="keyword">of</span> <span><a href="../../Isla/index.html#type-rtrc">Isla.rtrc</a> list</span></code></td></tr><tr id="type-traces.Traces" class="anchored"><td class="def constructor"><a href="#type-traces.Traces" class="anchor"></a><code>| </code><code><span class="constructor">Traces</span> <span class="keyword">of</span> <span><a href="../../Trace/index.html#type-t">Trace.t</a> list</span></code></td></tr></table></dt></dl><dl><dt class="spec value" id="val-instr"><a href="#val-instr" class="anchor"></a><code><span class="keyword">val</span> instr : <span>string Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-dump_trace"><a href="#val-dump_trace" class="anchor"></a><code><span class="keyword">val</span> dump_trace : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-dump_isla"><a href="#val-dump_isla" class="anchor"></a><code><span class="keyword">val</span> dump_isla : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-no_run"><a href="#val-no_run" class="anchor"></a><code><span class="keyword">val</span> no_run : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-isla_run"><a href="#val-isla_run" class="anchor"></a><code><span class="keyword">val</span> isla_run : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_trace"><a href="#val-simp_trace" class="anchor"></a><code><span class="keyword">val</span> simp_trace : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_state"><a href="#val-simp_state" class="anchor"></a><code><span class="keyword">val</span> simp_state : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp"><a href="#val-simp" class="anchor"></a><code><span class="keyword">val</span> simp : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-reg_types"><a href="#val-reg_types" class="anchor"></a><code><span class="keyword">val</span> reg_types : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span><span>string option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-get_instr"><a href="#val-get_instr" class="anchor"></a><code><span class="keyword">val</span> get_instr : <a href="../../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>string option</span> <span>&#45;&gt;</span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></code></dt><dt class="spec value" id="val-instr_term"><a href="#val-instr_term" class="anchor"></a><code><span class="keyword">val</span> instr_term : <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_trace_term"><a href="#val-simp_trace_term" class="anchor"></a><code><span class="keyword">val</span> simp_trace_term : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_state_term"><a href="#val-simp_state_term" class="anchor"></a><code><span class="keyword">val</span> simp_state_term : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-get_traces"><a href="#val-get_traces" class="anchor"></a><code><span class="keyword">val</span> get_traces : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-traces">traces</a></code></dt><dt class="spec value" id="val-pre_traces_term"><a href="#val-pre_traces_term" class="anchor"></a><code><span class="keyword">val</span> pre_traces_term : <span><a href="index.html#type-traces">traces</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-simp_traces"><a href="#val-simp_traces" class="anchor"></a><code><span class="keyword">val</span> simp_traces : bool <span>&#45;&gt;</span> <a href="index.html#type-traces">traces</a> <span>&#45;&gt;</span> <a href="index.html#type-traces">traces</a></code></dt><dt class="spec value" id="val-dump_traces"><a href="#val-dump_traces" class="anchor"></a><code><span class="keyword">val</span> dump_traces : bool <span>&#45;&gt;</span> <a href="index.html#type-traces">traces</a> <span>&#45;&gt;</span> <a href="index.html#type-traces">traces</a></code></dt><dt class="spec value" id="val-traces_term"><a href="#val-traces_term" class="anchor"></a><code><span class="keyword">val</span> traces_term : <span><a href="index.html#type-traces">traces</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-run_instr"><a href="#val-run_instr" class="anchor"></a><code><span class="keyword">val</span> run_instr : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-traces">traces</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Instr (read-dwarf.Run.Instr)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Instr</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Instr</span></code></h1><p>This module add the <code>run-instr</code> sub command.</p><p>This subcommand is about testing the various operations that can happen in an instruction processing. This is not <code>isla-test</code>, the instructions will always be fetched from the cache and use <a href="../Init/index.html"><code>Init</code></a>. If this fail at an earlier point, use <code>isla-test</code> to debug the Isla pipeline</p><p>Additionally <code>run-instr</code> supports branching instructions.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-traces"><a href="#type-traces" class="anchor"></a><code><span><span class="keyword">type</span> traces</span><span> = </span></code><ol><li id="type-traces.IslaTraces" class="def variant constructor anchored"><a href="#type-traces.IslaTraces" class="anchor"></a><code><span>| </span><span><span class="constructor">IslaTraces</span> <span class="keyword">of</span> <span><a href="../../Isla/index.html#type-rtrc">Isla.rtrc</a> list</span></span></code></li><li id="type-traces.Traces" class="def variant constructor anchored"><a href="#type-traces.Traces" class="anchor"></a><code><span>| </span><span><span class="constructor">Traces</span> <span class="keyword">of</span> <span><a href="../../Trace/index.html#type-t">Trace.t</a> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-instr"><a href="#val-instr" class="anchor"></a><code><span><span class="keyword">val</span> instr : <span>string <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dump_trace"><a href="#val-dump_trace" class="anchor"></a><code><span><span class="keyword">val</span> dump_trace : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dump_isla"><a href="#val-dump_isla" class="anchor"></a><code><span><span class="keyword">val</span> dump_isla : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-no_run"><a href="#val-no_run" class="anchor"></a><code><span><span class="keyword">val</span> no_run : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-isla_run"><a href="#val-isla_run" class="anchor"></a><code><span><span class="keyword">val</span> isla_run : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_trace"><a href="#val-simp_trace" class="anchor"></a><code><span><span class="keyword">val</span> simp_trace : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_state"><a href="#val-simp_state" class="anchor"></a><code><span><span class="keyword">val</span> simp_state : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp"><a href="#val-simp" class="anchor"></a><code><span><span class="keyword">val</span> simp : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reg_types"><a href="#val-reg_types" class="anchor"></a><code><span><span class="keyword">val</span> reg_types : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span><span>string option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_instr"><a href="#val-get_instr" class="anchor"></a><code><span><span class="keyword">val</span> get_instr : <span><a href="../../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-instr_term"><a href="#val-instr_term" class="anchor"></a><code><span><span class="keyword">val</span> instr_term : <span><a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_trace_term"><a href="#val-simp_trace_term" class="anchor"></a><code><span><span class="keyword">val</span> simp_trace_term : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_state_term"><a href="#val-simp_state_term" class="anchor"></a><code><span><span class="keyword">val</span> simp_state_term : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_traces"><a href="#val-get_traces" class="anchor"></a><code><span><span class="keyword">val</span> get_traces : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-traces">traces</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pre_traces_term"><a href="#val-pre_traces_term" class="anchor"></a><code><span><span class="keyword">val</span> pre_traces_term : <span><a href="#type-traces">traces</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simp_traces"><a href="#val-simp_traces" class="anchor"></a><code><span><span class="keyword">val</span> simp_traces : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-traces">traces</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-traces">traces</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dump_traces"><a href="#val-dump_traces" class="anchor"></a><code><span><span class="keyword">val</span> dump_traces : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-traces">traces</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-traces">traces</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-traces_term"><a href="#val-traces_term" class="anchor"></a><code><span><span class="keyword">val</span> traces_term : <span><a href="#type-traces">traces</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run_instr"><a href="#val-run_instr" class="anchor"></a><code><span><span class="keyword">val</span> run_instr : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-traces">traces</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/ReadDwarf/index.html b/doc/html/read-dwarf/Run/ReadDwarf/index.html
index 6db2c59b..6c8de8d1 100644
--- a/doc/html/read-dwarf/Run/ReadDwarf/index.html
+++ b/doc/html/read-dwarf/Run/ReadDwarf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ReadDwarf (read-dwarf.Run.ReadDwarf)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; ReadDwarf</nav><h1>Module <code>Run.ReadDwarf</code></h1></header><aside><p>This module implements the <code>rd</code> subcommand. This was to original meaning of &quot;read-dwarf&quot;, and the first command.</p><p>Together with <a href="../FuncRD/index.html"><span><code>run-func-rd</code></span></a>, this is the main user of the <a href="../../Analyse/index.html"><code>Analyse</code></a> code.</p></aside><dl><dt class="spec value" id="val-dry_run"><a href="#val-dry_run" class="anchor"></a><code><span class="keyword">val</span> dry_run : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-skylight"><a href="#val-skylight" class="anchor"></a><code><span class="keyword">val</span> skylight : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-comp_dir"><a href="#val-comp_dir" class="anchor"></a><code><span class="keyword">val</span> comp_dir : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-clip_binary"><a href="#val-clip_binary" class="anchor"></a><code><span class="keyword">val</span> clip_binary : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-no_vars"><a href="#val-no_vars" class="anchor"></a><code><span class="keyword">val</span> no_vars : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-no_cfa"><a href="#val-no_cfa" class="anchor"></a><code><span class="keyword">val</span> no_cfa : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-no_source"><a href="#val-no_source" class="anchor"></a><code><span class="keyword">val</span> no_source : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-objdump_d"><a href="#val-objdump_d" class="anchor"></a><code><span class="keyword">val</span> objdump_d : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-branch_tables"><a href="#val-branch_tables" class="anchor"></a><code><span class="keyword">val</span> branch_tables : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span class="keyword">val</span> elf : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-objdump_d2"><a href="#val-objdump_d2" class="anchor"></a><code><span class="keyword">val</span> objdump_d2 : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-branch_tables2"><a href="#val-branch_tables2" class="anchor"></a><code><span class="keyword">val</span> branch_tables2 : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-elf2"><a href="#val-elf2" class="anchor"></a><code><span class="keyword">val</span> elf2 : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-qemu_log"><a href="#val-qemu_log" class="anchor"></a><code><span class="keyword">val</span> qemu_log : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-out_file"><a href="#val-out_file" class="anchor"></a><code><span class="keyword">val</span> out_file : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-out_dir"><a href="#val-out_dir" class="anchor"></a><code><span class="keyword">val</span> out_dir : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-cfg_dot_file"><a href="#val-cfg_dot_file" class="anchor"></a><code><span class="keyword">val</span> cfg_dot_file : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-cfg_source_nodes"><a href="#val-cfg_source_nodes" class="anchor"></a><code><span class="keyword">val</span> cfg_source_nodes : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-cfg_source_nodes2"><a href="#val-cfg_source_nodes2" class="anchor"></a><code><span class="keyword">val</span> cfg_source_nodes2 : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-html"><a href="#val-html" class="anchor"></a><code><span class="keyword">val</span> html : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-options"><a href="#val-options" class="anchor"></a><code><span class="keyword">val</span> options : <span><span>unit Cmdliner.Term.t</span> list</span></code></dt><dt class="spec value" id="val-full_term"><a href="#val-full_term" class="anchor"></a><code><span class="keyword">val</span> full_term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ReadDwarf (read-dwarf.Run.ReadDwarf)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; ReadDwarf</nav><header class="odoc-preamble"><h1>Module <code><span>Run.ReadDwarf</span></code></h1><p>This module implements the <code>rd</code> subcommand. This was to original meaning of &quot;read-dwarf&quot;, and the first command.</p><p>Together with <a href="../FuncRD/index.html" title="Run.FuncRD"><code>run-func-rd</code></a>, this is the main user of the <a href="../../Analyse/index.html"><code>Analyse</code></a> code.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-dry_run"><a href="#val-dry_run" class="anchor"></a><code><span><span class="keyword">val</span> dry_run : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-skylight"><a href="#val-skylight" class="anchor"></a><code><span><span class="keyword">val</span> skylight : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-comp_dir"><a href="#val-comp_dir" class="anchor"></a><code><span><span class="keyword">val</span> comp_dir : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clip_binary"><a href="#val-clip_binary" class="anchor"></a><code><span><span class="keyword">val</span> clip_binary : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-no_vars"><a href="#val-no_vars" class="anchor"></a><code><span><span class="keyword">val</span> no_vars : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-no_cfa"><a href="#val-no_cfa" class="anchor"></a><code><span><span class="keyword">val</span> no_cfa : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-no_source"><a href="#val-no_source" class="anchor"></a><code><span><span class="keyword">val</span> no_source : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-objdump_d"><a href="#val-objdump_d" class="anchor"></a><code><span><span class="keyword">val</span> objdump_d : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-branch_tables"><a href="#val-branch_tables" class="anchor"></a><code><span><span class="keyword">val</span> branch_tables : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf"><a href="#val-elf" class="anchor"></a><code><span><span class="keyword">val</span> elf : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-objdump_d2"><a href="#val-objdump_d2" class="anchor"></a><code><span><span class="keyword">val</span> objdump_d2 : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-branch_tables2"><a href="#val-branch_tables2" class="anchor"></a><code><span><span class="keyword">val</span> branch_tables2 : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elf2"><a href="#val-elf2" class="anchor"></a><code><span><span class="keyword">val</span> elf2 : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-qemu_log"><a href="#val-qemu_log" class="anchor"></a><code><span><span class="keyword">val</span> qemu_log : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-out_file"><a href="#val-out_file" class="anchor"></a><code><span><span class="keyword">val</span> out_file : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-out_dir"><a href="#val-out_dir" class="anchor"></a><code><span><span class="keyword">val</span> out_dir : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfg_dot_file"><a href="#val-cfg_dot_file" class="anchor"></a><code><span><span class="keyword">val</span> cfg_dot_file : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfg_source_nodes"><a href="#val-cfg_source_nodes" class="anchor"></a><code><span><span class="keyword">val</span> cfg_source_nodes : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfg_source_nodes2"><a href="#val-cfg_source_nodes2" class="anchor"></a><code><span><span class="keyword">val</span> cfg_source_nodes2 : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-html"><a href="#val-html" class="anchor"></a><code><span><span class="keyword">val</span> html : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-morello"><a href="#val-morello" class="anchor"></a><code><span><span class="keyword">val</span> morello : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-suppress_stuff"><a href="#val-suppress_stuff" class="anchor"></a><code><span><span class="keyword">val</span> suppress_stuff : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-options"><a href="#val-options" class="anchor"></a><code><span><span class="keyword">val</span> options : <span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-full_term"><a href="#val-full_term" class="anchor"></a><code><span><span class="keyword">val</span> full_term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/Runner/index.html b/doc/html/read-dwarf/Run/Runner/index.html
index b146d078..dc45282f 100644
--- a/doc/html/read-dwarf/Run/Runner/index.html
+++ b/doc/html/read-dwarf/Run/Runner/index.html
@@ -1,2 +1,8 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Runner (read-dwarf.Run.Runner)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Runner</nav><h1>Module <code>Run.Runner</code></h1></header><aside><p>This module provide the program runner that caches all the information required to make a state transition</p><p>Later this module will handle inlining in a transparent way, and may also compress basic block traces (We'll need to check this is okay with type inference)</p><p>For now this module load instructions on a per-symbol basis, and do not try to load instructions outside of function symbol. TODO: remove this restriction.</p><p>The final goal of this module is to encode all necessary information to perform a state transition. In particular, the <a href="index.html#val-run"><code>run</code></a> function should never require more argument: If extra information is required, it should be part of the runner if it is dependent on the whole program or in the state if it is specific to the state.</p></aside><div class="spec module" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span class="keyword">module</span> Reg = <a href="../../State/index.html#module-Reg">State.Reg</a></code></div><dl><dt class="spec type" id="type-slot"><a href="#type-slot" class="anchor"></a><code><span class="keyword">type</span> slot</code><code> = </code><table class="variant"><tr id="type-slot.Normal" class="anchored"><td class="def constructor"><a href="#type-slot.Normal" class="anchor"></a><code>| </code><code><span class="constructor">Normal</span> <span class="keyword">of</span> <a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a></code></td><td class="doc"><p>The traces and the size of the instruction</p></td></tr><tr id="type-slot.Special" class="anchored"><td class="def constructor"><a href="#type-slot.Special" class="anchor"></a><code>| </code><code><span class="constructor">Special</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>Special instructions. Will be used to represent external events</p></td></tr><tr id="type-slot.Nocode" class="anchored"><td class="def constructor"><a href="#type-slot.Nocode" class="anchor"></a><code>| </code><code><span class="constructor">Nocode</span></code></td><td class="doc"><p>The is no code at this address. Running it is UB. Also used if an address is in between instructions</p></td></tr><tr id="type-slot.IslaFail" class="anchored"><td class="def constructor"><a href="#type-slot.IslaFail" class="anchor"></a><code>| </code><code><span class="constructor">IslaFail</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>This means Isla pipeline failed on that instruction</p></td></tr></table></dt><dd><p>Give the instruction descriptor at a given address</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.elf" class="anchored"><td class="def field"><a href="#type-t.elf" class="anchor"></a><code>elf : <a href="../../Elf/File/index.html#type-t">Elf.File.t</a>;</code></td></tr><tr id="type-t.dwarf" class="anchored"><td class="def field"><a href="#type-t.dwarf" class="anchor"></a><code>dwarf : <span><a href="../../Dw/index.html#type-t">Dw.t</a> option</span>;</code></td></tr><tr id="type-t.instrs" class="anchored"><td class="def field"><a href="#type-t.instrs" class="anchor"></a><code>instrs : <span><span>(int, <a href="index.html#type-slot">slot</a>)</span> Stdlib.Hashtbl.t</span>;</code></td><td class="doc"><p>Instruction cache</p></td></tr><tr id="type-t.pc" class="anchored"><td class="def field"><a href="#type-t.pc" class="anchor"></a><code>pc : <a href="../../State/Reg/index.html#type-t">Reg.t</a>;</code></td></tr><tr id="type-t.funcs" class="anchored"><td class="def field"><a href="#type-t.funcs" class="anchor"></a><code>funcs : <span>int <a href="../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</code></td><td class="doc"><p>Loaded functions by loading order</p></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-of_elf"><a href="#val-of_elf" class="anchor"></a><code><span class="keyword">val</span> of_elf : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-of_dwarf"><a href="#val-of_dwarf" class="anchor"></a><code><span class="keyword">val</span> of_dwarf : <a href="../../Dw/index.html#type-t">Dw.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-load_sym"><a href="#val-load_sym" class="anchor"></a><code><span class="keyword">val</span> load_sym : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Elf/Symbol/index.html#type-t">Elf.Symbol.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Load a symbol into the runner. All instruction traces are fetched and cached.</p><p>TODO support variable length instructions.</p></dd></dl><dl><dt class="spec value" id="val-fetch"><a href="#val-fetch" class="anchor"></a><code><span class="keyword">val</span> fetch : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-slot">slot</a></code></dt><dd><p>Fetch an instruction, and return corresponding slot.</p></dd></dl><dl><dt class="spec value" id="val-execute_normal"><a href="#val-execute_normal" class="anchor"></a><code><span class="keyword">val</span> execute_normal : <span>?&#8288;prelock:<span>(<a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> unit)</span></span> <span>&#45;&gt;</span> <span>pc:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><a href="../../State/index.html#type-t">State.t</a> list</span></code></dt><dd><p>Run the traces on the state.</p><p>If the state is unlocked and the instruction is single trace, then the function mutates the state and returns the same state.</p><p>Otherwise the state is locked (if not) and new states are returned</p><p>In any case the returned states are unlocked.</p></dd></dl><dl><dt class="spec value" id="val-skip"><a href="#val-skip" class="anchor"></a><code><span class="keyword">val</span> skip : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><a href="../../State/index.html#type-t">State.t</a> list</span></code></dt><dt class="spec value" id="val-run"><a href="#val-run" class="anchor"></a><code><span class="keyword">val</span> run : <span>?&#8288;prelock:<span>(<a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> unit)</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><a href="../../State/index.html#type-t">State.t</a> list</span></code></dt><dd><p>Do the whole fetch and execute cycle. Take the PC from the state, and fetch it's <a href="../Instr/index.html"><span>instruction</span></a> and then run it. It return the list of possible behavior of that instruction. Normally the union of the set of concrete states represented by this list of symbolic state cover all the defined behaviors of the fetched instruction from the initial state.</p><p>If the state is unlocked and the instruction is single trace, then the function mutates the state and returns the same state.</p><p>Otherwise the state is locked (if not) and new unlocked states are returned.</p><p>In any case the returned states are unlocked.</p></dd></dl><dl><dt class="spec value" id="val-expect_normal"><a href="#val-expect_normal" class="anchor"></a><code><span class="keyword">val</span> expect_normal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a></code></dt><dd><p>Return the <span class="xref-unresolved" title="unresolved reference to &quot;Instr.t&quot;"><a href="../index.html#module-Instr"><code>Instr</code></a>.t</span> data of the instruction at address, and throw <code>Not_found</code> if the instruction was invalid</p></dd></dl><dl><dt class="spec value" id="val-get_normal_opt"><a href="#val-get_normal_opt" class="anchor"></a><code><span class="keyword">val</span> get_normal_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a> option</span></code></dt><dd><p>Return the <span class="xref-unresolved" title="unresolved reference to &quot;Instr.t&quot;"><a href="../index.html#module-Instr"><code>Instr</code></a>.t</span> data of the instruction at address, and <code>None</code> if the instruction was invalid</p></dd></dl><dl><dt class="spec value" id="val-pp_slot"><a href="#val-pp_slot" class="anchor"></a><code><span class="keyword">val</span> pp_slot : <a href="index.html#type-slot">slot</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty prints a instruction slot</p></dd></dl><dl><dt class="spec value" id="val-pp_instr"><a href="#val-pp_instr" class="anchor"></a><code><span class="keyword">val</span> pp_instr : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Dump instruction table</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Runner (read-dwarf.Run.Runner)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Run</a> &#x00BB; Runner</nav><header class="odoc-preamble"><h1>Module <code><span>Run.Runner</span></code></h1><p>This module provide the program runner that caches all the information required to make a state transition</p><p>Later this module will handle inlining in a transparent way, and may also compress basic block traces (We'll need to check this is okay with type inference)</p><p>For now this module load instructions on a per-symbol basis, and do not try to load instructions outside of function symbol. TODO: remove this restriction.</p><p>The final goal of this module is to encode all necessary information to perform a state transition. In particular, the <a href="#val-run"><code>run</code></a> function should never require more argument: If extra information is required, it should be part of the runner if it is dependent on the whole program or in the state if it is specific to the state.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span><span class="keyword">module</span> Reg</span><span> = <a href="../../State/Reg/index.html">State.Reg</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-slot"><a href="#type-slot" class="anchor"></a><code><span><span class="keyword">type</span> slot</span><span> = </span></code><ol><li id="type-slot.Normal" class="def variant constructor anchored"><a href="#type-slot.Normal" class="anchor"></a><code><span>| </span><span><span class="constructor">Normal</span> <span class="keyword">of</span> <a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The traces and the size of the instruction</p><span class="comment-delim">*)</span></div></li><li id="type-slot.Special" class="def variant constructor anchored"><a href="#type-slot.Special" class="anchor"></a><code><span>| </span><span><span class="constructor">Special</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Special instructions. Will be used to represent external events</p><span class="comment-delim">*)</span></div></li><li id="type-slot.Nocode" class="def variant constructor anchored"><a href="#type-slot.Nocode" class="anchor"></a><code><span>| </span><span><span class="constructor">Nocode</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The is no code at this address. Running it is UB. Also used if an address is in between instructions</p><span class="comment-delim">*)</span></div></li><li id="type-slot.IslaFail" class="def variant constructor anchored"><a href="#type-slot.IslaFail" class="anchor"></a><code><span>| </span><span><span class="constructor">IslaFail</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>This means Isla pipeline failed on that instruction</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>Give the instruction descriptor at a given address</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.elf" class="def record field anchored"><a href="#type-t.elf" class="anchor"></a><code><span>elf : <a href="../../Elf/File/index.html#type-t">Elf.File.t</a>;</span></code></li><li id="type-t.dwarf" class="def record field anchored"><a href="#type-t.dwarf" class="anchor"></a><code><span>dwarf : <span><a href="../../Dw/index.html#type-t">Dw.t</a> option</span>;</span></code></li><li id="type-t.instrs" class="def record field anchored"><a href="#type-t.instrs" class="anchor"></a><code><span>instrs : <span><span>(<a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a>, <a href="#type-slot">slot</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Instruction cache</p><span class="comment-delim">*)</span></div></li><li id="type-t.pc" class="def record field anchored"><a href="#type-t.pc" class="anchor"></a><code><span>pc : <a href="../../State/Reg/index.html#type-t">Reg.t</a>;</span></code></li><li id="type-t.funcs" class="def record field anchored"><a href="#type-t.funcs" class="anchor"></a><code><span>funcs : <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <a href="../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Loaded functions by loading order</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_elf"><a href="#val-of_elf" class="anchor"></a><code><span><span class="keyword">val</span> of_elf : <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_dwarf"><a href="#val-of_dwarf" class="anchor"></a><code><span><span class="keyword">val</span> of_dwarf : <span><a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-load_sym"><a href="#val-load_sym" class="anchor"></a><code><span><span class="keyword">val</span> load_sym : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Symbol/index.html#type-t">Elf.Symbol.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Load a symbol into the runner. All instruction traces are fetched and cached.</p><p>TODO support variable length instructions.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fetch"><a href="#val-fetch" class="anchor"></a><code><span><span class="keyword">val</span> fetch : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-slot">slot</a></span></code></div><div class="spec-doc"><p>Fetch an instruction, and return corresponding slot.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-execute_normal"><a href="#val-execute_normal" class="anchor"></a><code><span><span class="keyword">val</span> execute_normal : 
+  <span><span class="optlabel">?prelock</span>:<span>(<span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">pc</span>:<a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> list</span></span></code></div><div class="spec-doc"><p>Run the traces on the state.</p><p>If the state is unlocked and the instruction is single trace, then the function mutates the state and returns the same state.</p><p>Otherwise the state is locked (if not) and new states are returned</p><p>In any case the returned states are unlocked.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-skip"><a href="#val-skip" class="anchor"></a><code><span><span class="keyword">val</span> skip : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-run"><a href="#val-run" class="anchor"></a><code><span><span class="keyword">val</span> run : <span><span class="optlabel">?prelock</span>:<span>(<span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-t">State.t</a> list</span></span></code></div><div class="spec-doc"><p>Do the whole fetch and execute cycle. Take the PC from the state, and fetch it's <a href="../Instr/index.html" title="Instr">instruction</a> and then run it. It return the list of possible behavior of that instruction. Normally the union of the set of concrete states represented by this list of symbolic state cover all the defined behaviors of the fetched instruction from the initial state.</p><p>If the state is unlocked and the instruction is single trace, then the function mutates the state and returns the same state.</p><p>Otherwise the state is locked (if not) and new unlocked states are returned.</p><p>In any case the returned states are unlocked.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_normal"><a href="#val-expect_normal" class="anchor"></a><code><span><span class="keyword">val</span> expect_normal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a></span></code></div><div class="spec-doc"><p>Return the <code>Instr.t</code> data of the instruction at address, and throw <code>Not_found</code> if the instruction was invalid</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_normal_opt"><a href="#val-get_normal_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_normal_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Trace/Instr/index.html#type-t">Trace.Instr.t</a> option</span></span></code></div><div class="spec-doc"><p>Return the <code>Instr.t</code> data of the instruction at address, and <code>None</code> if the instruction was invalid</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_slot"><a href="#val-pp_slot" class="anchor"></a><code><span><span class="keyword">val</span> pp_slot : <span><a href="#type-slot">slot</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints a instruction slot</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_instr"><a href="#val-pp_instr" class="anchor"></a><code><span><span class="keyword">val</span> pp_instr : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Dump instruction table</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Run/index.html b/doc/html/read-dwarf/Run/index.html
index b1f686ce..9cdeb254 100644
--- a/doc/html/read-dwarf/Run/index.html
+++ b/doc/html/read-dwarf/Run/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Run (read-dwarf.Run)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Run</nav><h1>Module <code>Run</code></h1></header><dl><dt class="spec module" id="module-BB"><a href="#module-BB" class="anchor"></a><code><span class="keyword">module</span> <a href="BB/index.html">BB</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Bb_lib"><a href="#module-Bb_lib" class="anchor"></a><code><span class="keyword">module</span> <a href="Bb_lib/index.html">Bb_lib</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Block"><a href="#module-Block" class="anchor"></a><code><span class="keyword">module</span> <a href="Block/index.html">Block</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Block_lib"><a href="#module-Block_lib" class="anchor"></a><code><span class="keyword">module</span> <a href="Block_lib/index.html">Block_lib</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Func"><a href="#module-Func" class="anchor"></a><code><span class="keyword">module</span> <a href="Func/index.html">Func</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-FuncRD"><a href="#module-FuncRD" class="anchor"></a><code><span class="keyword">module</span> <a href="FuncRD/index.html">FuncRD</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Init"><a href="#module-Init" class="anchor"></a><code><span class="keyword">module</span> <a href="Init/index.html">Init</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Instr"><a href="#module-Instr" class="anchor"></a><code><span class="keyword">module</span> <a href="Instr/index.html">Instr</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-ReadDwarf"><a href="#module-ReadDwarf" class="anchor"></a><code><span class="keyword">module</span> <a href="ReadDwarf/index.html">ReadDwarf</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Runner"><a href="#module-Runner" class="anchor"></a><code><span class="keyword">module</span> <a href="Runner/index.html">Runner</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Run (read-dwarf.Run)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Run</nav><header class="odoc-preamble"><h1>Module <code><span>Run</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-BB"><a href="#module-BB" class="anchor"></a><code><span><span class="keyword">module</span> <a href="BB/index.html">BB</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module allow to do a test run of all the machinery for a single basic block</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Bb_lib"><a href="#module-Bb_lib" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Bb_lib/index.html">Bb_lib</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide code to manipulate basic block and run them.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Block"><a href="#module-Block" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Block/index.html">Block</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module add the <code>run-block</code> sub command.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Block_lib"><a href="#module-Block_lib" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Block_lib/index.html">Block_lib</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides a representation of a complex block of code.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Func"><a href="#module-Func" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Func/index.html">Func</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-FuncRD"><a href="#module-FuncRD" class="anchor"></a><code><span><span class="keyword">module</span> <a href="FuncRD/index.html">FuncRD</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is a merge of <code>rd</code> sub command and <code>run-func --loop=1</code>. It will run the equivalent of <code>run-func --loop=1</code>, and print the instruction like <code>rd</code> but will print the state in a light form (<a href="../State/index.html#val-pp_partial"><code>State.pp_partial</code></a>) between instructions.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Init"><a href="#module-Init" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Init/index.html">Init</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module handle architecture initialization. For now it trust default isla initialization but this should change soon (TODO)</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Instr"><a href="#module-Instr" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Instr/index.html">Instr</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module add the <code>run-instr</code> sub command.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ReadDwarf"><a href="#module-ReadDwarf" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ReadDwarf/index.html">ReadDwarf</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module implements the <code>rd</code> subcommand. This was to original meaning of &quot;read-dwarf&quot;, and the first command.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-RelProg"><a href="#module-RelProg" class="anchor"></a><code><span><span class="keyword">module</span> <a href="RelProg/index.html">RelProg</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Runner"><a href="#module-Runner" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Runner/index.html">Runner</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide the program runner that caches all the information required to make a state transition</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-TestRelProg"><a href="#module-TestRelProg" class="anchor"></a><code><span><span class="keyword">module</span> <a href="TestRelProg/index.html">TestRelProg</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Sig/index.html b/doc/html/read-dwarf/Sig/index.html
index af8ce19c..aa8f7eaf 100644
--- a/doc/html/read-dwarf/Sig/index.html
+++ b/doc/html/read-dwarf/Sig/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sig (read-dwarf.Sig)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Sig</nav><h1>Module <code>Sig</code></h1><p>This module define all architecture-dependent configuration</p><p>It should be used instead of <a href="../Arch/index.html"><code>Arch</code></a> inside the architecture dependent modules.</p><p>Everything inside this module is copied into <a href="../Arch/index.html"><code>Arch</code></a>, so module that can depend on <a href="../Arch/index.html"><code>Arch</code></a> may do so.</p></header><dl><dt class="spec type" id="type-func_api"><a href="#type-func_api" class="anchor"></a><code><span class="keyword">type</span> func_api</code><code> = </code><code>{</code><table class="record"><tr id="type-func_api.args" class="anchored"><td class="def field"><a href="#type-func_api.args" class="anchor"></a><code>args : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> list</span>;</code></td></tr><tr id="type-func_api.ret" class="anchored"><td class="def field"><a href="#type-func_api.ret" class="anchor"></a><code>ret : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> option</span>;</code></td></tr></table><code>}</code></dt><dd><p>Describe the C API of a function</p></dd></dl><dl><dt class="spec type" id="type-func_abi"><a href="#type-func_abi" class="anchor"></a><code><span class="keyword">type</span> func_abi</code><code> = </code><code>{</code><table class="record"><tr id="type-func_abi.init" class="anchored"><td class="def field"><a href="#type-func_abi.init" class="anchor"></a><code>init : <a href="../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../State/index.html#type-t">State.t</a>;</code></td><td class="doc"><p>Gives the initial state for verifying the function, from a given global register state. Only global registers are kept.</p></td></tr></table><code>}</code></dt><dd><p>Describe the ABI of a function</p><p>This is a record because I expect to add many other fields later.</p></dd></dl><dl><dt class="spec type" id="type-dwarf_reg_map"><a href="#type-dwarf_reg_map" class="anchor"></a><code><span class="keyword">type</span> dwarf_reg_map</code><code> = <span><a href="../State/Reg/index.html#type-t">State.Reg.t</a> array</span></code></dt><dd><p>The map of dwarf register: Which register number map to which ISA register</p></dd></dl><dl><dt class="spec value" id="val-supports"><a href="#val-supports" class="anchor"></a><code><span class="keyword">val</span> supports : <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tells if this Arch module supports this architecture</p></dd></dl><dl><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : <a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>If this arch module <a href="index.html#val-supports"><code>supports</code></a> the architecture, then initialize read-dwarf state using this architecture</p></dd></dl><dl><dt class="spec value" id="val-initialized"><a href="#val-initialized" class="anchor"></a><code><span class="keyword">val</span> initialized : unit <span>&#45;&gt;</span> <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> option</span></code></dt><dd><p>Return <code>Some(arch)</code> is the loaded arch is <code>arch</code> and <code>None</code> if nothing is loaded yet.</p></dd></dl><dl><dt class="spec value" id="val-module_name"><a href="#val-module_name" class="anchor"></a><code><span class="keyword">val</span> module_name : string</code></dt><dd><p>The name of the arch module. Must be the name of the module i.e. <code>Config.arch_module</code></p></dd></dl><dl><dt class="spec value" id="val-loaded_name"><a href="#val-loaded_name" class="anchor"></a><code><span class="keyword">val</span> loaded_name : string</code></dt><dd><p>For dynamic arch module, the name of the dynamically loaded module. Otherwise <a href="index.html#val-module_name"><code>module_name</code></a></p></dd></dl><dl><dt class="spec value" id="val-address_size"><a href="#val-address_size" class="anchor"></a><code><span class="keyword">val</span> address_size : int</code></dt><dd><p>The true size of addresses for memory operation</p></dd></dl><dl><dt class="spec value" id="val-dwarf_reg_map"><a href="#val-dwarf_reg_map" class="anchor"></a><code><span class="keyword">val</span> dwarf_reg_map : unit <span>&#45;&gt;</span> <a href="index.html#type-dwarf_reg_map">dwarf_reg_map</a></code></dt><dd><p>Get the register map of the architecture</p></dd></dl><dl><dt class="spec value" id="val-is_local"><a href="#val-is_local" class="anchor"></a><code><span class="keyword">val</span> is_local : <a href="../State/Reg/index.html#type-t">State.Reg.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if a register is local for the ABI</p></dd></dl><dl><dt class="spec value" id="val-nop"><a href="#val-nop" class="anchor"></a><code><span class="keyword">val</span> nop : unit <span>&#45;&gt;</span> <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></code></dt><dd><p>Give the opcode of the nop instruction (For Sail/Isla initialisation</p></dd></dl><dl><dt class="spec value" id="val-get_abi"><a href="#val-get_abi" class="anchor"></a><code><span class="keyword">val</span> get_abi : <a href="index.html#type-func_api">func_api</a> <span>&#45;&gt;</span> <a href="index.html#type-func_abi">func_abi</a></code></dt><dd><p>Give the ABI of a function from it's C API</p></dd></dl><dl><dt class="spec value" id="val-pc"><a href="#val-pc" class="anchor"></a><code><span class="keyword">val</span> pc : unit <span>&#45;&gt;</span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></code></dt><dd><p>Give the register index for the program counter</p></dd></dl><dl><dt class="spec value" id="val-sp"><a href="#val-sp" class="anchor"></a><code><span class="keyword">val</span> sp : unit <span>&#45;&gt;</span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></code></dt><dd><p>Give the register index for the stack pointer</p></dd></dl><dl><dt class="spec value" id="val-assemble_to_elf"><a href="#val-assemble_to_elf" class="anchor"></a><code><span class="keyword">val</span> assemble_to_elf : string <span>&#45;&gt;</span> string</code></dt><dd><p>Take an instruction string and give the name of an temporary ELF file created that contains the instruction at symbol instr.</p></dd></dl><dl><dt class="spec value" id="val-split_into_instrs"><a href="#val-split_into_instrs" class="anchor"></a><code><span class="keyword">val</span> split_into_instrs : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> list</span></code></dt><dd><p>Split a byte-sequence into a list of instructions.</p></dd></dl><dl><dt class="spec value" id="val-is_ret"><a href="#val-is_ret" class="anchor"></a><code><span class="keyword">val</span> is_ret : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if an instruction is a return instruction.</p></dd></dl><dl><dt class="spec value" id="val-is_cmp"><a href="#val-is_cmp" class="anchor"></a><code><span class="keyword">val</span> is_cmp : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><span>(<a href="../State/Reg/index.html#type-t">State.Reg.t</a> * <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a>)</span> option</span></code></dt><dd><p>Tell if an instruction is a compare instruction. Returns <code>Some (reg,bv)</code> where the contents of <code>reg</code> are compared against the value <code>bv</code> if it is and <code>None</code> if not.</p></dd></dl><dl><dt class="spec value" id="val-is_bl"><a href="#val-is_bl" class="anchor"></a><code><span class="keyword">val</span> is_bl : <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> option</span></code></dt><dd><p>Tell if an instruction is an (unconditional) branch on immediate with link instructions. Returns <code>Some bv</code> where <code>bv</code> is the offset (from the address of this instruction, in the range +/-128MB) that is branched to if it is and <code>None</code> if not.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sig (read-dwarf.Sig)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Sig</nav><header class="odoc-preamble"><h1>Module <code><span>Sig</span></code></h1><p>This module define all architecture-dependent configuration</p><p>It should be used instead of <a href="../Arch/index.html"><code>Arch</code></a> inside the architecture dependent modules.</p><p>Everything inside this module is copied into <a href="../Arch/index.html"><code>Arch</code></a>, so module that can depend on <a href="../Arch/index.html"><code>Arch</code></a> may do so.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-func_api"><a href="#type-func_api" class="anchor"></a><code><span><span class="keyword">type</span> func_api</span><span> = </span><span>{</span></code><ol><li id="type-func_api.args" class="def record field anchored"><a href="#type-func_api.args" class="anchor"></a><code><span>args : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> list</span>;</span></code></li><li id="type-func_api.ret" class="def record field anchored"><a href="#type-func_api.ret" class="anchor"></a><code><span>ret : <span><a href="../Ctype/index.html#type-t">Ctype.t</a> option</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Describe the C API of a function</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-func_abi"><a href="#type-func_abi" class="anchor"></a><code><span><span class="keyword">type</span> func_abi</span><span> = </span><span>{</span></code><ol><li id="type-func_abi.init" class="def record field anchored"><a href="#type-func_abi.init" class="anchor"></a><code><span>init : <span><a href="../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../State/index.html#type-t">State.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Gives the initial state for verifying the function, from a given global register state. Only global registers are kept.</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Describe the ABI of a function</p><p>This is a record because I expect to add many other fields later.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-dwarf_reg_map"><a href="#type-dwarf_reg_map" class="anchor"></a><code><span><span class="keyword">type</span> dwarf_reg_map</span><span> = <span><a href="../State/Reg/index.html#type-t">State.Reg.t</a> array</span></span></code></div><div class="spec-doc"><p>The map of dwarf register: Which register number map to which ISA register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-supports"><a href="#val-supports" class="anchor"></a><code><span><span class="keyword">val</span> supports : <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tells if this Arch module supports this architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>If this arch module <a href="#val-supports"><code>supports</code></a> the architecture, then initialize read-dwarf state using this architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-initialized"><a href="#val-initialized" class="anchor"></a><code><span><span class="keyword">val</span> initialized : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><a href="../Config/Arch/index.html#type-t">Config.Arch.t</a> option</span></span></code></div><div class="spec-doc"><p>Return <code>Some(arch)</code> is the loaded arch is <code>arch</code> and <code>None</code> if nothing is loaded yet.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-module_name"><a href="#val-module_name" class="anchor"></a><code><span><span class="keyword">val</span> module_name : string</span></code></div><div class="spec-doc"><p>The name of the arch module. Must be the name of the module i.e. <code>Config.arch_module</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-loaded_name"><a href="#val-loaded_name" class="anchor"></a><code><span><span class="keyword">val</span> loaded_name : string</span></code></div><div class="spec-doc"><p>For dynamic arch module, the name of the dynamically loaded module. Otherwise <a href="#val-module_name"><code>module_name</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-address_size"><a href="#val-address_size" class="anchor"></a><code><span><span class="keyword">val</span> address_size : int</span></code></div><div class="spec-doc"><p>The true size of addresses for memory operation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dwarf_reg_map"><a href="#val-dwarf_reg_map" class="anchor"></a><code><span><span class="keyword">val</span> dwarf_reg_map : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-dwarf_reg_map">dwarf_reg_map</a></span></code></div><div class="spec-doc"><p>Get the register map of the architecture</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_local"><a href="#val-is_local" class="anchor"></a><code><span><span class="keyword">val</span> is_local : <span><a href="../State/Reg/index.html#type-t">State.Reg.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if a register is local for the ABI</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nop"><a href="#val-nop" class="anchor"></a><code><span><span class="keyword">val</span> nop : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a></span></code></div><div class="spec-doc"><p>Give the opcode of the nop instruction (For Sail/Isla initialisation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_abi"><a href="#val-get_abi" class="anchor"></a><code><span><span class="keyword">val</span> get_abi : <span><a href="#type-func_api">func_api</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-func_abi">func_abi</a></span></code></div><div class="spec-doc"><p>Give the ABI of a function from it's C API</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pc"><a href="#val-pc" class="anchor"></a><code><span><span class="keyword">val</span> pc : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></span></code></div><div class="spec-doc"><p>Give the register index for the program counter</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sp"><a href="#val-sp" class="anchor"></a><code><span><span class="keyword">val</span> sp : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../State/Reg/index.html#type-t">State.Reg.t</a></span></code></div><div class="spec-doc"><p>Give the register index for the stack pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assemble_to_elf"><a href="#val-assemble_to_elf" class="anchor"></a><code><span><span class="keyword">val</span> assemble_to_elf : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Take an instruction string and give the name of an temporary ELF file created that contains the instruction at symbol instr.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_into_instrs"><a href="#val-split_into_instrs" class="anchor"></a><code><span><span class="keyword">val</span> split_into_instrs : <span><a href="../Elf/Symbol/index.html#type-data">Elf.Symbol.data</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Elf/Symbol/index.html#type-data">Elf.Symbol.data</a> list</span></span></code></div><div class="spec-doc"><p>Split a byte-sequence into a list of instructions.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_ret"><a href="#val-is_ret" class="anchor"></a><code><span><span class="keyword">val</span> is_ret : <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if an instruction is a return instruction.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_cmp"><a href="#val-is_cmp" class="anchor"></a><code><span><span class="keyword">val</span> is_cmp : <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../State/Reg/index.html#type-t">State.Reg.t</a> * <a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a>)</span> option</span></span></code></div><div class="spec-doc"><p>Tell if an instruction is a compare instruction. Returns <code>Some (reg,bv)</code> where the contents of <code>reg</code> are compared against the value <code>bv</code> if it is and <code>None</code> if not.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_bl"><a href="#val-is_bl" class="anchor"></a><code><span><span class="keyword">val</span> is_bl : <span><a href="../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> option</span></span></code></div><div class="spec-doc"><p>Tell if an instruction is an (unconditional) branch on immediate with link instructions. Returns <code>Some bv</code> where <code>bv</code> is the offset (from the address of this instruction, in the range +/-128MB) that is branched to if it is and <code>None</code> if not.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Simrel/Base/MemRel/index.html b/doc/html/read-dwarf/Simrel/Base/MemRel/index.html
index 4b3263f7..5d5baa24 100644
--- a/doc/html/read-dwarf/Simrel/Base/MemRel/index.html
+++ b/doc/html/read-dwarf/Simrel/Base/MemRel/index.html
@@ -1,2 +1,5 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>MemRel (read-dwarf.Simrel.Base.MemRel)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; MemRel</nav><h1>Module <code>Base.MemRel</code></h1></header><dl><dt class="spec type" id="type-block"><a href="#type-block" class="anchor"></a><code><span class="keyword">type</span> block</code><code> = <a href="../../../State__Base/Mem/Fragment/Block/index.html#type-t">State.Mem.Fragment.Block.t</a></code></dt></dl><dl><dt class="spec value" id="val-of_int"><a href="#val-of_int" class="anchor"></a><code><span class="keyword">val</span> of_int : int <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span></code></dt><dt class="spec value" id="val-eq_block"><a href="#val-eq_block" class="anchor"></a><code><span class="keyword">val</span> eq_block : <a href="index.html#type-block">block</a> <span>&#45;&gt;</span> <a href="index.html#type-block">block</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span> * <span><span>(<a href="../../../State__Base/Mem/Fragment/index.html#type-var">State__Base.Mem.Fragment.var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span></code></dt></dl><dl><dt class="spec type" id="type-event"><a href="#type-event" class="anchor"></a><code><span class="keyword">type</span> event</code><code> = <a href="../../../State__Base/Mem/Fragment/Event/index.html#type-t">State.Mem.Fragment.Event.t</a></code></dt><dt class="spec type" id="type-trace"><a href="#type-trace" class="anchor"></a><code><span class="keyword">type</span> trace</code><code> = <span><a href="index.html#type-event">event</a> list</span></code></dt></dl><dl><dt class="spec value" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span class="keyword">val</span> eq : <a href="index.html#type-trace">trace</a> <span>&#45;&gt;</span> <a href="index.html#type-trace">trace</a> <span>&#45;&gt;</span> <span><span><span>(<a href="../../../State__Base/Mem/Fragment/index.html#type-var">State__Base.Mem.Fragment.var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></code></dt><dd><p>For now, just assume an equality relation for memory</p></dd></dl><dl><dt class="spec value" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span class="keyword">val</span> eq : <a href="../../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><span><span>(<a href="../../../State__Base/Mem/Fragment/index.html#type-var">State__Base.Mem.Fragment.var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>MemRel (read-dwarf.Simrel.Base.MemRel)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; MemRel</nav><header class="odoc-preamble"><h1>Module <code><span>Base.MemRel</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-block"><a href="#type-block" class="anchor"></a><code><span><span class="keyword">type</span> block</span><span> = <a href="../../../State/Base/Mem/Fragment/Block/index.html#type-t">State.Mem.Fragment.Block.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_int"><a href="#val-of_int" class="anchor"></a><code><span><span class="keyword">val</span> of_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eq_block"><a href="#val-eq_block" class="anchor"></a><code><span><span class="keyword">val</span> eq_block : 
+  <span><a href="#type-block">block</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-block">block</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span> * <span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-event"><a href="#type-event" class="anchor"></a><code><span><span class="keyword">type</span> event</span><span> = <a href="../../../State/Base/Mem/Fragment/Event/index.html#type-t">State.Mem.Fragment.Event.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trace"><a href="#type-trace" class="anchor"></a><code><span><span class="keyword">type</span> trace</span><span> = <span><a href="#type-event">event</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span><span class="keyword">val</span> eq : <span><a href="../../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Simrel/Base/RegRel/index.html b/doc/html/read-dwarf/Simrel/Base/RegRel/index.html
index 52e441db..6e29fbd6 100644
--- a/doc/html/read-dwarf/Simrel/Base/RegRel/index.html
+++ b/doc/html/read-dwarf/Simrel/Base/RegRel/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>RegRel (read-dwarf.Simrel.Base.RegRel)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; RegRel</nav><h1>Module <code>Base.RegRel</code></h1></header><dl><dt class="spec value" id="val-reg_map_fold"><a href="#val-reg_map_fold" class="anchor"></a><code><span class="keyword">val</span> reg_map_fold : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../../../State__Reg/Map/index.html#type-reg">Reg.Map.reg</a> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="../../../State__Reg/Map/index.html#type-t">Reg.Map.t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-present"><a href="#val-present" class="anchor"></a><code><span class="keyword">val</span> present : <span><span><a href="../../../State/Reg/index.html#type-t">Reg.t</a> <a href="../../../Utils/index.html#module-List">Utils.List</a>.t</span> option</span> <span>&#45;&gt;</span> <a href="../../../State/Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span class="keyword">val</span> eq : <span>?&#8288;except:<span><a href="../../../State/Reg/index.html#type-t">Reg.t</a> <a href="../../../Utils/index.html#module-List">Utils.List</a>.t</span></span> <span>&#45;&gt;</span> <a href="../../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><span>(<a href="../../../State__Base/Exp/index.html#type-var">State__Base.Exp.var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span></code></dt><dd><p>This is not symmetric (does it need to be?). NOTE: If there is a reg in st2 that is not in st1, it will not be checked. Example: test3, O2, state 1, __defaultRAM -&gt; |reg:0:__defaultRAM| (not in O0)</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>RegRel (read-dwarf.Simrel.Base.RegRel)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; RegRel</nav><header class="odoc-preamble"><h1>Module <code><span>Base.RegRel</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-reg_map_fold"><a href="#val-reg_map_fold" class="anchor"></a><code><span><span class="keyword">val</span> reg_map_fold : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../State/Reg/Map/index.html#type-reg">Reg.Map.reg</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="../../../State/Reg/Map/index.html#type-t">Reg.Map.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-present"><a href="#val-present" class="anchor"></a><code><span><span class="keyword">val</span> present : <span><span><span><a href="../../../State/Reg/index.html#type-t">Reg.t</a> <a href="../../../Utils/List/index.html#type-t">Utils.List.t</a></span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../State/Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eq"><a href="#val-eq" class="anchor"></a><code><span><span class="keyword">val</span> eq : 
+  <span><span class="optlabel">?except</span>:<span><a href="../../../State/Reg/index.html#type-t">Reg.t</a> <a href="../../../Utils/List/index.html#type-t">Utils.List.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">ExTy.t</a></span></span></code></div><div class="spec-doc"><p>This is not symmetric (does it need to be?). NOTE: If there is a reg in st2 that is not in st1, it will not be checked. Example: test3, O2, state 1, __defaultRAM -&gt; |reg:0:__defaultRAM| (not in O0)</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Simrel/Base/Test2/index.html b/doc/html/read-dwarf/Simrel/Base/Test2/index.html
index d848a2c2..64e03f12 100644
--- a/doc/html/read-dwarf/Simrel/Base/Test2/index.html
+++ b/doc/html/read-dwarf/Simrel/Base/Test2/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test2 (read-dwarf.Simrel.Base.Test2)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Test2</nav><h1>Module <code>Base.Test2</code></h1></header><dl><dt class="spec value" id="val-infer_rels"><a href="#val-infer_rels" class="anchor"></a><code><span class="keyword">val</span> infer_rels : <span><span><span class="type-var">'a</span> <a href="../../../State/Tree/index.html#type-t">State.Tree.t</a></span> <a href="../index.html#type-pair">pair</a></span> <span>&#45;&gt;</span> <a href="../index.html#type-rels">rels</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test2 (read-dwarf.Simrel.Base.Test2)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Test2</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Test2</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-infer_rels"><a href="#val-infer_rels" class="anchor"></a><code><span><span class="keyword">val</span> infer_rels : <span><span><span><span class="type-var">'a</span> <a href="../../../State/Tree/index.html#type-t">State.Tree.t</a></span> <a href="../index.html#type-pair">pair</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-rels">rels</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Simrel/Base/Test3/index.html b/doc/html/read-dwarf/Simrel/Base/Test3/index.html
index fa2ae331..ee8c84da 100644
--- a/doc/html/read-dwarf/Simrel/Base/Test3/index.html
+++ b/doc/html/read-dwarf/Simrel/Base/Test3/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test3 (read-dwarf.Simrel.Base.Test3)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Test3</nav><h1>Module <code>Base.Test3</code></h1></header><dl><dt class="spec value" id="val-infer_rels"><a href="#val-infer_rels" class="anchor"></a><code><span class="keyword">val</span> infer_rels : <span><span><span class="type-var">'a</span> <a href="../../../State/Tree/index.html#type-t">State.Tree.t</a></span> <a href="../index.html#type-pair">pair</a></span> <span>&#45;&gt;</span> <a href="../index.html#type-rels">rels</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test3 (read-dwarf.Simrel.Base.Test3)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Simrel</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Test3</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Test3</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-infer_rels"><a href="#val-infer_rels" class="anchor"></a><code><span><span class="keyword">val</span> infer_rels : <span><span><span><span class="type-var">'a</span> <a href="../../../State/Tree/index.html#type-t">State.Tree.t</a></span> <a href="../index.html#type-pair">pair</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-rels">rels</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Simrel/Base/index.html b/doc/html/read-dwarf/Simrel/Base/index.html
index 5497e80e..d40910bb 100644
--- a/doc/html/read-dwarf/Simrel/Base/index.html
+++ b/doc/html/read-dwarf/Simrel/Base/index.html
@@ -1,2 +1,9 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Simrel.Base)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Simrel</a> &#x00BB; Base</nav><h1>Module <code>Simrel.Base</code></h1></header><aside><p>This module encodes the definition and checking of the simulation relation.</p></aside><div class="spec module" id="module-Tree"><a href="#module-Tree" class="anchor"></a><code><span class="keyword">module</span> Tree = <a href="../../State/index.html#module-Tree">State.Tree</a></code></div><div class="spec module" id="module-ExTy"><a href="#module-ExTy" class="anchor"></a><code><span class="keyword">module</span> ExTy = <a href="../../Exp/index.html#module-Typed">Exp.Typed</a></code></div><div class="spec module" id="module-Tval"><a href="#module-Tval" class="anchor"></a><code><span class="keyword">module</span> Tval = <a href="../../State/index.html#module-Tval">State.Tval</a></code></div><div class="spec module" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span class="keyword">module</span> Reg = <a href="../../State/index.html#module-Reg">State.Reg</a></code></div><div class="spec module" id="module-Simplify"><a href="#module-Simplify" class="anchor"></a><code><span class="keyword">module</span> Simplify = <a href="../../State/index.html#module-Simplify">State.Simplify</a></code></div><div class="spec module" id="module-Z3St"><a href="#module-Z3St" class="anchor"></a><code><span class="keyword">module</span> Z3St = <a href="../../State/Simplify/index.html#module-Z3St">State.Simplify.Z3St</a></code></div><div class="spec module" id="module-Id"><a href="#module-Id" class="anchor"></a><code><span class="keyword">module</span> Id = <a href="../../State/index.html#module-Id">State.Id</a></code></div><dl><dt class="spec type" id="type-tree"><a href="#type-tree" class="anchor"></a><code><span class="keyword">type</span> tree</code><code> = <span><a href="../../Run/Block_lib/index.html#type-label">Run.Block_lib.label</a> <a href="../../State/Tree/index.html#type-t">Tree.t</a></span></code></dt><dt class="spec type" id="type-pair"><a href="#type-pair" class="anchor"></a><code><span class="keyword">type</span> <span>'a pair</span></code><code> = </code><code>{</code><table class="record"><tr id="type-pair.o0" class="anchored"><td class="def field"><a href="#type-pair.o0" class="anchor"></a><code>o0 : <span class="type-var">'a</span>;</code></td></tr><tr id="type-pair.o2" class="anchored"><td class="def field"><a href="#type-pair.o2" class="anchor"></a><code>o2 : <span class="type-var">'a</span>;</code></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-rel_of"><a href="#val-rel_of" class="anchor"></a><code><span class="keyword">val</span> rel_of : <span><span><span><span>(<a href="../../State__Base/Exp/index.html#type-var">State__Base.Exp.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span> <a href="index.html#type-pair">pair</a></span> list</span> <span>&#45;&gt;</span> <a href="../../State__Base/Tval/index.html#type-t">Tval.t</a> <span>&#45;&gt;</span> <a href="../../State__Base/Tval/index.html#type-t">Tval.t</a> <span>&#45;&gt;</span> <span><span>(<a href="../../State__Base/Exp/index.html#type-var">State__Base.Exp.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span></code></dt></dl><dl><dt class="spec type" id="type-field"><a href="#type-field" class="anchor"></a><code><span class="keyword">type</span> field</code><code> = </code><table class="variant"><tr id="type-field.Reg" class="anchored"><td class="def constructor"><a href="#type-field.Reg" class="anchor"></a><code>| </code><code><span class="constructor">Reg</span> <span class="keyword">of</span> <a href="../../State/Reg/index.html#type-t">Reg.t</a></code></td></tr></table></dt><dt class="spec type" id="type-sep"><a href="#type-sep" class="anchor"></a><code><span class="keyword">type</span> sep</code><code> = </code><table class="variant"><tr id="type-sep.Eq" class="anchored"><td class="def constructor"><a href="#type-sep.Eq" class="anchor"></a><code>| </code><code><span class="constructor">Eq</span> <span class="keyword">of</span> <span><span><a href="index.html#type-field">field</a> <a href="index.html#type-pair">pair</a></span> list</span></code></td></tr></table></dt><dt class="spec type" id="type-rel"><a href="#type-rel" class="anchor"></a><code><span class="keyword">type</span> rel</code><code> = </code><table class="variant"><tr id="type-rel.Same" class="anchored"><td class="def constructor"><a href="#type-rel.Same" class="anchor"></a><code>| </code><code><span class="constructor">Same</span></code></td></tr><tr id="type-rel.Star" class="anchored"><td class="def constructor"><a href="#type-rel.Star" class="anchor"></a><code>| </code><code><span class="constructor">Star</span> <span class="keyword">of</span> <a href="index.html#type-sep">sep</a> * <a href="index.html#type-rel">rel</a></code></td></tr></table></dt><dd><p>Same should always be at the end.</p></dd></dl><dl><dt class="spec type" id="type-matched"><a href="#type-matched" class="anchor"></a><code><span class="keyword">type</span> matched</code><code> = </code><table class="variant"><tr id="type-matched.Matched" class="anchored"><td class="def constructor"><a href="#type-matched.Matched" class="anchor"></a><code>| </code><code><span class="constructor">Matched</span> <span class="keyword">of</span> <span><a href="../../State/index.html#type-t">State.t</a> <a href="index.html#type-pair">pair</a></span> * <a href="index.html#type-rel">rel</a></code></td></tr><tr id="type-matched.NoMatch" class="anchored"><td class="def constructor"><a href="#type-matched.NoMatch" class="anchor"></a><code>| </code><code><span class="constructor">NoMatch</span> <span class="keyword">of</span> <a href="../../State/index.html#type-t">State.t</a></code></td></tr></table></dt><dt class="spec type" id="type-rels"><a href="#type-rels" class="anchor"></a><code><span class="keyword">type</span> rels</code><code> = <span><a href="index.html#type-matched">matched</a> list</span></code></dt></dl><div class="spec module" id="module-Test2"><a href="#module-Test2" class="anchor"></a><code><span class="keyword">module</span> <a href="Test2/index.html">Test2</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Test3"><a href="#module-Test3" class="anchor"></a><code><span class="keyword">module</span> <a href="Test3/index.html">Test3</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-MemRel"><a href="#module-MemRel" class="anchor"></a><code><span class="keyword">module</span> <a href="MemRel/index.html">MemRel</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-RegRel"><a href="#module-RegRel" class="anchor"></a><code><span class="keyword">module</span> <a href="RegRel/index.html">RegRel</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-sep_to_exp"><a href="#val-sep_to_exp" class="anchor"></a><code><span class="keyword">val</span> sep_to_exp : <span><a href="../../State/index.html#type-t">State.t</a> <a href="index.html#type-pair">pair</a></span> <span>&#45;&gt;</span> <a href="index.html#type-sep">sep</a> <span>&#45;&gt;</span> <span><a href="index.html#type-field">field</a> list</span> * <span><span><span>(<a href="../../State__Base/Exp/index.html#type-var">State__Base.Exp.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></code></dt><dt class="spec value" id="val-assn_to_exp"><a href="#val-assn_to_exp" class="anchor"></a><code><span class="keyword">val</span> assn_to_exp : <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <span><span>(<a href="../../State__Base/Exp/index.html#type-var">State.Exp.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span></code></dt><dt class="spec value" id="val-rel_to_exp"><a href="#val-rel_to_exp" class="anchor"></a><code><span class="keyword">val</span> rel_to_exp : <span><a href="../../State/index.html#type-t">State.t</a> <a href="index.html#type-pair">pair</a></span> <span>&#45;&gt;</span> <a href="index.html#type-rel">rel</a> <span>&#45;&gt;</span> <span><span><span>(<a href="../../State__Base/Exp/index.html#type-var">State__Base.Exp.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></code></dt><dt class="spec value" id="val-check_rel"><a href="#val-check_rel" class="anchor"></a><code><span class="keyword">val</span> check_rel : <span><a href="index.html#type-matched">matched</a> list</span> <span>&#45;&gt;</span> bool</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Simrel.Base)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Simrel</a> &#x00BB; Base</nav><header class="odoc-preamble"><h1>Module <code><span>Simrel.Base</span></code></h1><p>This module encodes the definition and checking of the simulation relation.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Tree"><a href="#module-Tree" class="anchor"></a><code><span><span class="keyword">module</span> Tree</span><span> = <a href="../../State/Tree/index.html">State.Tree</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ExTy"><a href="#module-ExTy" class="anchor"></a><code><span><span class="keyword">module</span> ExTy</span><span> = <a href="../../Exp/Typed/index.html">Exp.Typed</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Tval"><a href="#module-Tval" class="anchor"></a><code><span><span class="keyword">module</span> Tval</span><span> = <a href="../../State/Base/Tval/index.html">State.Tval</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span><span class="keyword">module</span> Reg</span><span> = <a href="../../State/Reg/index.html">State.Reg</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Simplify"><a href="#module-Simplify" class="anchor"></a><code><span><span class="keyword">module</span> Simplify</span><span> = <a href="../../State/Simplify/index.html">State.Simplify</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Z3St"><a href="#module-Z3St" class="anchor"></a><code><span><span class="keyword">module</span> Z3St</span><span> = <a href="../../State/Simplify/Z3St/index.html">State.Simplify.Z3St</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Id"><a href="#module-Id" class="anchor"></a><code><span><span class="keyword">module</span> Id</span><span> = <a href="../../State/Base/Id/index.html">State.Id</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tree"><a href="#type-tree" class="anchor"></a><code><span><span class="keyword">type</span> tree</span><span> = <span><a href="../../Run/Block_lib/index.html#type-label">Run.Block_lib.label</a> <a href="../../State/Tree/index.html#type-t">Tree.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-pair"><a href="#type-pair" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a pair</span></span><span> = </span><span>{</span></code><ol><li id="type-pair.o0" class="def record field anchored"><a href="#type-pair.o0" class="anchor"></a><code><span>o0 : <span class="type-var">'a</span>;</span></code></li><li id="type-pair.o2" class="def record field anchored"><a href="#type-pair.o2" class="anchor"></a><code><span>o2 : <span class="type-var">'a</span>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rel_of"><a href="#val-rel_of" class="anchor"></a><code><span><span class="keyword">val</span> rel_of : 
+  <span><span><span><span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span> <a href="#type-pair">pair</a></span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/Base/Tval/index.html#type-t">Tval.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/Base/Tval/index.html#type-t">Tval.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-field"><a href="#type-field" class="anchor"></a><code><span><span class="keyword">type</span> field</span><span> = </span></code><ol><li id="type-field.Reg" class="def variant constructor anchored"><a href="#type-field.Reg" class="anchor"></a><code><span>| </span><span><span class="constructor">Reg</span> <span class="keyword">of</span> <a href="../../State/Reg/index.html#type-t">Reg.t</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-sep"><a href="#type-sep" class="anchor"></a><code><span><span class="keyword">type</span> sep</span><span> = </span></code><ol><li id="type-sep.Eq" class="def variant constructor anchored"><a href="#type-sep.Eq" class="anchor"></a><code><span>| </span><span><span class="constructor">Eq</span> <span class="keyword">of</span> <span><span><a href="#type-field">field</a> <a href="#type-pair">pair</a></span> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rel"><a href="#type-rel" class="anchor"></a><code><span><span class="keyword">type</span> rel</span><span> = </span></code><ol><li id="type-rel.Same" class="def variant constructor anchored"><a href="#type-rel.Same" class="anchor"></a><code><span>| </span><span><span class="constructor">Same</span></span></code></li><li id="type-rel.Star" class="def variant constructor anchored"><a href="#type-rel.Star" class="anchor"></a><code><span>| </span><span><span class="constructor">Star</span> <span class="keyword">of</span> <a href="#type-sep">sep</a> * <a href="#type-rel">rel</a></span></code></li></ol></div><div class="spec-doc"><p>Same should always be at the end.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-matched"><a href="#type-matched" class="anchor"></a><code><span><span class="keyword">type</span> matched</span><span> = </span></code><ol><li id="type-matched.Matched" class="def variant constructor anchored"><a href="#type-matched.Matched" class="anchor"></a><code><span>| </span><span><span class="constructor">Matched</span> <span class="keyword">of</span> <span><a href="../../State/index.html#type-t">State.t</a> <a href="#type-pair">pair</a></span> * <a href="#type-rel">rel</a></span></code></li><li id="type-matched.NoMatch" class="def variant constructor anchored"><a href="#type-matched.NoMatch" class="anchor"></a><code><span>| </span><span><span class="constructor">NoMatch</span> <span class="keyword">of</span> <a href="../../State/index.html#type-t">State.t</a></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-rels"><a href="#type-rels" class="anchor"></a><code><span><span class="keyword">type</span> rels</span><span> = <span><a href="#type-matched">matched</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Test2"><a href="#module-Test2" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Test2/index.html">Test2</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Test3"><a href="#module-Test3" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Test3/index.html">Test3</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-MemRel"><a href="#module-MemRel" class="anchor"></a><code><span><span class="keyword">module</span> <a href="MemRel/index.html">MemRel</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-RegRel"><a href="#module-RegRel" class="anchor"></a><code><span><span class="keyword">module</span> <a href="RegRel/index.html">RegRel</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sep_to_exp"><a href="#val-sep_to_exp" class="anchor"></a><code><span><span class="keyword">val</span> sep_to_exp : 
+  <span><span><a href="../../State/index.html#type-t">State.t</a> <a href="#type-pair">pair</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-sep">sep</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-field">field</a> list</span> * <span><span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assn_to_exp"><a href="#val-assn_to_exp" class="anchor"></a><code><span><span class="keyword">val</span> assn_to_exp : <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../../State/Base/Exp/index.html#type-var">State.Exp.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rel_to_exp"><a href="#val-rel_to_exp" class="anchor"></a><code><span><span class="keyword">val</span> rel_to_exp : <span><span><a href="../../State/index.html#type-t">State.t</a> <a href="#type-pair">pair</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-rel">rel</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="xref-unresolved">State__Base.Var.t</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">ExTy.t</a></span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_rel"><a href="#val-check_rel" class="anchor"></a><code><span><span class="keyword">val</span> check_rel : <span><span><a href="#type-matched">matched</a> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Simrel/index.html b/doc/html/read-dwarf/Simrel/index.html
index 7c456945..30f4450a 100644
--- a/doc/html/read-dwarf/Simrel/index.html
+++ b/doc/html/read-dwarf/Simrel/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Simrel (read-dwarf.Simrel)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Simrel</nav><h1>Module <code>Simrel</code></h1></header><dl><dt class="spec module" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span class="keyword">module</span> <a href="Base/index.html">Base</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Simrel (read-dwarf.Simrel)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Simrel</nav><header class="odoc-preamble"><h1>Module <code><span>Simrel</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Base/index.html">Base</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module encodes the definition and checking of the simulation relation.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Exp/index.html b/doc/html/read-dwarf/State/Base/Exp/index.html
index 44e77e77..a2508ba5 100644
--- a/doc/html/read-dwarf/State/Base/Exp/index.html
+++ b/doc/html/read-dwarf/State/Base/Exp/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Exp (read-dwarf.State.Base.Exp)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Exp</nav><h1>Module <code>Base.Exp</code></h1><p>Module for state expressions</p></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../Exp/index.html#module-type-S">Exp.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../../Exp/module-type-S/index.html#type-var">var</a> = <a href="../index.html#type-var">var</a></code></span></summary><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../index.html#type-var">var</a></code></dt><dd><p>The type of variable provided in the functor</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dd><p>The type of expression on which this module works</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Test syntactic equality. <code>a + b</code> and <code>b + a</code> would test different under this predicate</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the expression using <a href="../../../Exp/PpExp/index.html"><code>Exp.PpExp</code></a></p></dd></dl><dl><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the expression in SMTLIB language</p></dd></dl><dl><dt class="spec value" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span class="keyword">val</span> of_var : <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create an expression from a variable</p></dd></dl><dl><dt class="spec value" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span class="keyword">val</span> add_type : <span><span>(<span class="type-var">'a</span>, <a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert a similar but untyped expression to an expression of type <a href="index.html#type-t"><code>t</code></a></p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span class="keyword">val</span> of_reg : <a href="../index.html#type-id">id</a> <span>&#45;&gt;</span> <a href="../../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create an expression from an register and a state id</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Exp (read-dwarf.State.Base.Exp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Exp</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Exp</span></code></h1><p>Module for state expressions</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../../Exp/module-type-S/index.html">Exp.S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../../Exp/module-type-S/index.html#type-var">var</a> = <a href="../index.html#type-var">var</a></span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../index.html#type-var">var</a></span></code></div><div class="spec-doc"><p>The type of variable provided in the functor</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div><div class="spec-doc"><p>The type of expression on which this module works</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test syntactic equality. <code>a + b</code> and <code>b + a</code> would test different under this predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the expression using <code>PpExp</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the expression in SMTLIB language</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span><span class="keyword">val</span> of_var : <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create an expression from a variable</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span><span class="keyword">val</span> add_type : <span><span><span>(<span class="type-var">'a</span>, <a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert a similar but untyped expression to an expression of type <a href="#type-t"><code>t</code></a></p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span><span class="keyword">val</span> of_reg : <span><a href="../index.html#type-id">id</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create an expression from an register and a state id</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_sym_address"><a href="#val-expect_sym_address" class="anchor"></a><code><span><span class="keyword">val</span> expect_sym_address : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Elf/Address/index.html#type-t">Elf.Address.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_section"><a href="#val-of_section" class="anchor"></a><code><span><span class="keyword">val</span> of_section : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_address"><a href="#val-of_address" class="anchor"></a><code><span><span class="keyword">val</span> of_address : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Id/index.html b/doc/html/read-dwarf/State/Base/Id/index.html
index a1d926b9..d5249712 100644
--- a/doc/html/read-dwarf/State/Base/Id/index.html
+++ b/doc/html/read-dwarf/State/Base/Id/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Id (read-dwarf.State.Base.Id)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Id</nav><h1>Module <code>Base.Id</code></h1><p>The type of a state ID. for now it's an integer, but it may change later In particular whether a state belong to O0 or O2 may be part of the <code>id</code> at some point.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Id (read-dwarf.State.Base.Id)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Id</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Id</span></code></h1><p>The type of a state ID. for now it's an integer, but it may change later In particular whether a state belong to O0 or O2 may be part of the <code>id</code> at some point.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Mem/Fragment/Block/index.html b/doc/html/read-dwarf/State/Base/Mem/Fragment/Block/index.html
index ea0e8a65..0ac5f837 100644
--- a/doc/html/read-dwarf/State/Base/Mem/Fragment/Block/index.html
+++ b/doc/html/read-dwarf/State/Base/Mem/Fragment/Block/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Block (read-dwarf.State.Base.Mem.Fragment.Block)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">State</a> &#x00BB; <a href="../../../index.html">Base</a> &#x00BB; <a href="../../index.html">Mem</a> &#x00BB; <a href="../index.html">Fragment</a> &#x00BB; Block</nav><h1>Module <code>Fragment.Block</code></h1><p>This module provide the concept of memory block, as used by a fragment.</p><p>The block represent a memory area that contain a single memory expression.</p><p>It may represent a symbolic or concrete address. In the fist case, It may also be concretely bounded.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span class="keyword">private</span> </code><code>{</code><table class="record"><tr id="type-t.base" class="anchored"><td class="def field"><a href="#type-t.base" class="anchor"></a><code>base : <span><a href="../index.html#type-exp">exp</a> option</span>;</code></td><td class="doc"><p>The symbolic base. If <code>None</code> the block is concrete</p></td></tr><tr id="type-t.offset" class="anchored"><td class="def field"><a href="#type-t.offset" class="anchor"></a><code>offset : int;</code></td><td class="doc"><p>The concrete part of the address</p></td></tr><tr id="type-t.size" class="anchored"><td class="def field"><a href="#type-t.size" class="anchor"></a><code>size : <a href="../../../../../AstGen__Def/Size/index.html#type-t">Size.t</a>;</code></td></tr><tr id="type-t.bounds" class="anchored"><td class="def field"><a href="#type-t.bounds" class="anchor"></a><code>bounds : <span><span>(int * int)</span> option</span>;</code></td><td class="doc"><p>Optional bounds: <code>(min, max)</code> means <code>[min:max)</code></p></td></tr></table><code>}</code></dt><dd><p>The type for representing memory blocks</p></dd></dl><dl><dt class="spec value" id="val-make_split"><a href="#val-make_split" class="anchor"></a><code><span class="keyword">val</span> make_split : <span>?&#8288;bounds:<span>(int * int)</span></span> <span>&#45;&gt;</span> <a href="../index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="../../../../../AstGen__Def/Size/index.html#type-t">Size.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Make the block from an address and a size. The address is automatically split between a symbolic and concrete part.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Block (read-dwarf.State.Base.Mem.Fragment.Block)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../../index.html">Index</a> &#x00BB; <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">State</a> &#x00BB; <a href="../../../index.html">Base</a> &#x00BB; <a href="../../index.html">Mem</a> &#x00BB; <a href="../index.html">Fragment</a> &#x00BB; Block</nav><header class="odoc-preamble"><h1>Module <code><span>Fragment.Block</span></code></h1><p>This module provide the concept of memory block, as used by a fragment.</p><p>The block represent a memory area that contain a single memory expression.</p><p>It may represent a symbolic or concrete address. In the fist case, It may also be concretely bounded.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span class="keyword">private</span> </span><span>{</span></code><ol><li id="type-t.base" class="def record field anchored"><a href="#type-t.base" class="anchor"></a><code><span>base : <span><a href="../index.html#type-exp">exp</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The symbolic base. If <code>None</code> the block is concrete</p><span class="comment-delim">*)</span></div></li><li id="type-t.offset" class="def record field anchored"><a href="#type-t.offset" class="anchor"></a><code><span>offset : int;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The concrete part of the address</p><span class="comment-delim">*)</span></div></li><li id="type-t.size" class="def record field anchored"><a href="#type-t.size" class="anchor"></a><code><span>size : <a href="../../../../../Ast/Base/Size/index.html#type-t">Size.t</a>;</span></code></li><li id="type-t.bounds" class="def record field anchored"><a href="#type-t.bounds" class="anchor"></a><code><span>bounds : <span><span>(int * int)</span> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Optional bounds: <code>(min, max)</code> means <code>[min:max)</code></p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type for representing memory blocks</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make_split"><a href="#val-make_split" class="anchor"></a><code><span><span class="keyword">val</span> make_split : <span><span class="optlabel">?bounds</span>:<span>(int * int)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../../../Ast/Base/Size/index.html#type-t">Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Make the block from an address and a size. The address is automatically split between a symbolic and concrete part.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Mem/Fragment/Event/index.html b/doc/html/read-dwarf/State/Base/Mem/Fragment/Event/index.html
index 614c05fb..7b1e6ae5 100644
--- a/doc/html/read-dwarf/State/Base/Mem/Fragment/Event/index.html
+++ b/doc/html/read-dwarf/State/Base/Mem/Fragment/Event/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Event (read-dwarf.State.Base.Mem.Fragment.Event)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">State</a> &#x00BB; <a href="../../../index.html">Base</a> &#x00BB; <a href="../../index.html">Mem</a> &#x00BB; <a href="../index.html">Fragment</a> &#x00BB; Event</nav><h1>Module <code>Fragment.Event</code></h1><p>This module provide the trace of reads and writes to a symbolic fragment.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.Read" class="anchored"><td class="def constructor"><a href="#type-t.Read" class="anchor"></a><code>| </code><code><span class="constructor">Read</span> <span class="keyword">of</span> <a href="../Block/index.html#type-t">Block.t</a> * <a href="../index.html#type-var">var</a></code></td><td class="doc"><p>From <code>Block.t</code>, read <code>var</code></p></td></tr><tr id="type-t.Write" class="anchored"><td class="def constructor"><a href="#type-t.Write" class="anchor"></a><code>| </code><code><span class="constructor">Write</span> <span class="keyword">of</span> <a href="../Block/index.html#type-t">Block.t</a> * <a href="../index.html#type-exp">exp</a></code></td><td class="doc"><p>To <code>Block.t</code>, write <code>exp</code></p></td></tr></table></dt><dd><p>Types of memory events</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Event (read-dwarf.State.Base.Mem.Fragment.Event)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../../index.html">Index</a> &#x00BB; <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">State</a> &#x00BB; <a href="../../../index.html">Base</a> &#x00BB; <a href="../../index.html">Mem</a> &#x00BB; <a href="../index.html">Fragment</a> &#x00BB; Event</nav><header class="odoc-preamble"><h1>Module <code><span>Fragment.Event</span></code></h1><p>This module provide the trace of reads and writes to a symbolic fragment.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.Read" class="def variant constructor anchored"><a href="#type-t.Read" class="anchor"></a><code><span>| </span><span><span class="constructor">Read</span> <span class="keyword">of</span> <a href="../Block/index.html#type-t">Block.t</a> * <a href="../index.html#type-var">var</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>From <code>Block.t</code>, read <code>var</code></p><span class="comment-delim">*)</span></div></li><li id="type-t.Write" class="def variant constructor anchored"><a href="#type-t.Write" class="anchor"></a><code><span>| </span><span><span class="constructor">Write</span> <span class="keyword">of</span> <a href="../Block/index.html#type-t">Block.t</a> * <a href="../index.html#type-exp">exp</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>To <code>Block.t</code>, write <code>exp</code></p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>Types of memory events</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Mem/Fragment/index.html b/doc/html/read-dwarf/State/Base/Mem/Fragment/index.html
index eea1a725..65a377f5 100644
--- a/doc/html/read-dwarf/State/Base/Mem/Fragment/index.html
+++ b/doc/html/read-dwarf/State/Base/Mem/Fragment/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Fragment (read-dwarf.State.Base.Mem.Fragment)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">State</a> &#x00BB; <a href="../../index.html">Base</a> &#x00BB; <a href="../index.html">Mem</a> &#x00BB; Fragment</nav><h1>Module <code>Mem.Fragment</code></h1></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../../Var/index.html#type-t">Var.t</a></code></dt><dd><p>The type of variables used</p></dd></dl><div class="spec module" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span class="keyword">module</span> Size = <a href="../../../../Ast/index.html#module-Size">Ast.Size</a></code></div><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dd><p>The type of expressions stored in the fragment</p></dd></dl><dl><dt class="spec module" id="module-Block"><a href="#module-Block" class="anchor"></a><code><span class="keyword">module</span> <a href="Block/index.html">Block</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide the concept of memory block, as used by a fragment.</p></dd></dl><dl><dt class="spec module" id="module-Event"><a href="#module-Event" class="anchor"></a><code><span class="keyword">module</span> <a href="Event/index.html">Event</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide the trace of reads and writes to a symbolic fragment.</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of a memory fragment</p></dd></dl><dl><dt class="spec value" id="val-get_trace"><a href="#val-get_trace" class="anchor"></a><code><span class="keyword">val</span> get_trace : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="Event/index.html#type-t">Event.t</a> list</span></code></dt><dd><p>Get the trace of given fragment</p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>The empty memory fragment. Any read will be symbolic</p></dd></dl><dl><dt class="spec value" id="val-from"><a href="#val-from" class="anchor"></a><code><span class="keyword">val</span> from : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Start a new memory fragment based on the previous one</p></dd></dl><dl><dt class="spec value" id="val-try_read"><a href="#val-try_read" class="anchor"></a><code><span class="keyword">val</span> try_read : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Block/index.html#type-t">Block.t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> option</span></code></dt><dd><p>Try to read a expression in a block. If one can provide a symbolic expression representing the content of the block then <code>Some</code> is returned, otherwise <code>None</code> is returned.</p></dd></dl><dl><dt class="spec value" id="val-try_read_naive"><a href="#val-try_read_naive" class="anchor"></a><code><span class="keyword">val</span> try_read_naive : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Block/index.html#type-t">Block.t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> option</span></code></dt><dd><p>Same semantic as <a href="index.html#val-try_read"><code>try_read</code></a> but ignores the caches. Is supposed to be slower.</p><p>The required property is that if <a href="index.html#val-try_read"><code>try_read</code></a> return <code>Some value</code> then <code>try_read_naive</code> must return the same value. It's possible that try_read_naive give a result when <a href="index.html#val-try_read"><code>try_read</code></a> don't</p></dd></dl><dl><dt class="spec value" id="val-read_sym"><a href="#val-read_sym" class="anchor"></a><code><span class="keyword">val</span> read_sym : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Block/index.html#type-t">Block.t</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Read a symbolic variable from a block. This bound this symbolic variable to the The content of the block in the current memory state.contents</p></dd></dl><dl><dt class="spec value" id="val-write"><a href="#val-write" class="anchor"></a><code><span class="keyword">val</span> write : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Block/index.html#type-t">Block.t</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Write a symbolic expression at a block</p></dd></dl><dl><dt class="spec value" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span class="keyword">val</span> map_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all contained expressions. This function must not change the semantic meaning of symbolic expressions in any way. It is intended to be used with simplifying functions and the like</p></dd></dl><dl><dt class="spec value" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span class="keyword">val</span> iter_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all contained expression. Expression may appear more or less than anticipated because of various caching.</p></dd></dl><dl><dt class="spec value" id="val-check_cache"><a href="#val-check_cache" class="anchor"></a><code><span class="keyword">val</span> check_cache : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Check cache integrity. Throw if something is wrong</p></dd></dl><dl><dt class="spec value" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span class="keyword">val</span> is_empty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tells if the memory is empty since it's initial base. (No new memory operation were added</p></dd></dl><dl><dt class="spec value" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span class="keyword">val</span> pp_raw : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints the raw internals fragment. TODO: A nice pretty printer</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Fragment (read-dwarf.State.Base.Mem.Fragment)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">State</a> &#x00BB; <a href="../../index.html">Base</a> &#x00BB; <a href="../index.html">Mem</a> &#x00BB; Fragment</nav><header class="odoc-preamble"><h1>Module <code><span>Mem.Fragment</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../../Var/index.html#type-t">Var.t</a></span></code></div><div class="spec-doc"><p>The type of variables used</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Size"><a href="#module-Size" class="anchor"></a><code><span><span class="keyword">module</span> Size</span><span> = <a href="../../../../Ast/Base/Size/index.html">Ast.Size</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div><div class="spec-doc"><p>The type of expressions stored in the fragment</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Block"><a href="#module-Block" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Block/index.html">Block</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide the concept of memory block, as used by a fragment.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Event"><a href="#module-Event" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Event/index.html">Event</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide the trace of reads and writes to a symbolic fragment.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of a memory fragment</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_trace"><a href="#val-get_trace" class="anchor"></a><code><span><span class="keyword">val</span> get_trace : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Event/index.html#type-t">Event.t</a> list</span></span></code></div><div class="spec-doc"><p>Get the trace of given fragment</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The empty memory fragment. Any read will be symbolic</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from"><a href="#val-from" class="anchor"></a><code><span><span class="keyword">val</span> from : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Start a new memory fragment based on the previous one</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-try_read"><a href="#val-try_read" class="anchor"></a><code><span><span class="keyword">val</span> try_read : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Block/index.html#type-t">Block.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> option</span></span></code></div><div class="spec-doc"><p>Try to read a expression in a block. If one can provide a symbolic expression representing the content of the block then <code>Some</code> is returned, otherwise <code>None</code> is returned.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-try_read_naive"><a href="#val-try_read_naive" class="anchor"></a><code><span><span class="keyword">val</span> try_read_naive : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Block/index.html#type-t">Block.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> option</span></span></code></div><div class="spec-doc"><p>Same semantic as <a href="#val-try_read"><code>try_read</code></a> but ignores the caches. Is supposed to be slower.</p><p>The required property is that if <a href="#val-try_read"><code>try_read</code></a> return <code>Some value</code> then <code>try_read_naive</code> must return the same value. It's possible that try_read_naive give a result when <a href="#val-try_read"><code>try_read</code></a> don't</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_sym"><a href="#val-read_sym" class="anchor"></a><code><span><span class="keyword">val</span> read_sym : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Block/index.html#type-t">Block.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Read a symbolic variable from a block. This bound this symbolic variable to the The content of the block in the current memory state.contents</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write"><a href="#val-write" class="anchor"></a><code><span><span class="keyword">val</span> write : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Block/index.html#type-t">Block.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Write a symbolic expression at a block</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span><span class="keyword">val</span> map_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all contained expressions. This function must not change the semantic meaning of symbolic expressions in any way. It is intended to be used with simplifying functions and the like</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> iter_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all contained expression. Expression may appear more or less than anticipated because of various caching.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_cache"><a href="#val-check_cache" class="anchor"></a><code><span><span class="keyword">val</span> check_cache : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Check cache integrity. Throw if something is wrong</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tells if the memory is empty since it's initial base. (No new memory operation were added</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_raw"><a href="#val-pp_raw" class="anchor"></a><code><span><span class="keyword">val</span> pp_raw : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints the raw internals fragment. TODO: A nice pretty printer</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Mem/index.html b/doc/html/read-dwarf/State/Base/Mem/index.html
index 787a820c..24df5155 100644
--- a/doc/html/read-dwarf/State/Base/Mem/index.html
+++ b/doc/html/read-dwarf/State/Base/Mem/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Mem (read-dwarf.State.Base.Mem)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Mem</nav><h1>Module <code>Base.Mem</code></h1><p>This module manages the memory part of the state.</p><p>The symbolic memory bounds certain symbolic address to symbolic values, but most addresses are not bound. This basically correspond to a concrete instantiation of a <code>SymbolicFragment</code>.</p><p>However in most case, we have some information that some symbolic value do not alias other symbolic values.For example in no address involving the stack pointer may alias any address no involving the stack pointer except in specific case of escaping which are explicitly not supported (yet). It is intended to support escaping later. There can be other kind of non-aliasing information in case of explicit <code>restrict</code> annotation or when implicitly passing or returning value by pointer (which some ABI do when such value are too big).</p><p>In the absence of escaping, such problem can be solved by representing the memory with multiple <code>SymbolicFragment</code>. One for the main memory, and one for each &quot;restricted block&quot;. The module encapsulate all those different fragment.</p><p>To manage such a system, we use the C type system to carry around provenance information in the type <a href="../../../Ctype/index.html#type-provenance"><code>Ctype.provenance</code></a>. When doing a <a href="../index.html#val-read"><code>read</code></a> or a <a href="../index.html#val-write"><code>write</code></a>, this provenance is used to route the read or write to the right symbolic block.</p><p>This means that the provenance-tracking part of the C type system must be part of the TCB of read-dwarf as the soundness of the symbolic memory model depend on it.</p><p>Finally, the current implementation is only suitable for sequential execution, a new theoretical model and implementation must be developed for concurrent shared memory.</p><p>Implementation detail: This type has an imperative interface even if the underlying <code>SymbolicFragment</code> has a pure interface.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-new_frag"><a href="#val-new_frag" class="anchor"></a><code><span class="keyword">val</span> new_frag : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="../../../Ctype/index.html#type-provenance">Ctype.provenance</a></code></dt><dd><p>Add a new fragment with the specified base</p></dd></dl><div class="spec module" id="module-Fragment"><a href="#module-Fragment" class="anchor"></a><code><span class="keyword">module</span> <a href="Fragment/index.html">Fragment</a> : <a href="../../../State__/SymbolicFragment/index.html#module-type-S">State__.SymbolicFragment.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../../State__/SymbolicFragment/module-type-S/index.html#type-var">var</a> = <a href="../Var/index.html#type-t">Var.t</a></code></div><dl><dt class="spec value" id="val-get_main"><a href="#val-get_main" class="anchor"></a><code><span class="keyword">val</span> get_main : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Fragment/index.html#type-t">Fragment.t</a></code></dt><dd><p>Get the main fragment of memory</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Mem (read-dwarf.State.Base.Mem)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Mem</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Mem</span></code></h1><p>This module manages the memory part of the state.</p><p>The symbolic memory bounds certain symbolic address to symbolic values, but most addresses are not bound. This basically correspond to a concrete instantiation of a <code>SymbolicFragment</code>.</p><p>However in most case, we have some information that some symbolic value do not alias other symbolic values.For example in no address involving the stack pointer may alias any address no involving the stack pointer except in specific case of escaping which are explicitly not supported (yet). It is intended to support escaping later. There can be other kind of non-aliasing information in case of explicit <code>restrict</code> annotation or when implicitly passing or returning value by pointer (which some ABI do when such value are too big).</p><p>In the absence of escaping, such problem can be solved by representing the memory with multiple <code>SymbolicFragment</code>. One for the main memory, and one for each &quot;restricted block&quot;. The module encapsulate all those different fragment.</p><p>To manage such a system, we use the C type system to carry around provenance information in the type <a href="../../../Ctype/index.html#type-provenance"><code>Ctype.provenance</code></a>. When doing a <a href="../index.html#val-read"><code>read</code></a> or a <a href="../index.html#val-write"><code>write</code></a>, this provenance is used to route the read or write to the right symbolic block.</p><p>This means that the provenance-tracking part of the C type system must be part of the TCB of read-dwarf as the soundness of the symbolic memory model depend on it.</p><p>Finally, the current implementation is only suitable for sequential execution, a new theoretical model and implementation must be developed for concurrent shared memory.</p><p>Implementation detail: This type has an imperative interface even if the underlying <code>SymbolicFragment</code> has a pure interface.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-new_frag"><a href="#val-new_frag" class="anchor"></a><code><span><span class="keyword">val</span> new_frag : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Ctype/index.html#type-provenance">Ctype.provenance</a></span></code></div><div class="spec-doc"><p>Add a new fragment with the specified base</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Fragment"><a href="#module-Fragment" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Fragment/index.html">Fragment</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_main"><a href="#val-get_main" class="anchor"></a><code><span><span class="keyword">val</span> get_main : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="Fragment/index.html#type-t">Fragment.t</a></span></code></div><div class="spec-doc"><p>Get the main fragment of memory</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_frag"><a href="#val-get_frag" class="anchor"></a><code><span><span class="keyword">val</span> get_frag : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../Exp/index.html#type-t">Exp.t</a> * <a href="Fragment/index.html#type-t">Fragment.t</a></span></code></div><div class="spec-doc"><p>Get fragment</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Tval/index.html b/doc/html/read-dwarf/State/Base/Tval/index.html
index 6839b24a..a6837807 100644
--- a/doc/html/read-dwarf/State/Base/Tval/index.html
+++ b/doc/html/read-dwarf/State/Base/Tval/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Tval (read-dwarf.State.Base.Tval)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Tval</nav><h1>Module <code>Base.Tval</code></h1><p>Module for optionally typed state expressions. Those are symbolic values which may or may not have a C type.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.ctyp" class="anchored"><td class="def field"><a href="#type-t.ctyp" class="anchor"></a><code>ctyp : <span><a href="../../../Ctype/index.html#type-t">Ctype.t</a> option</span>;</code></td></tr><tr id="type-t.exp" class="anchored"><td class="def field"><a href="#type-t.exp" class="anchor"></a><code>exp : <a href="../index.html#type-exp">exp</a>;</code></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;ctyp:<a href="../../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Make a new typed value with optionally a <a href="../../../Ctype/index.html"><code>Ctype</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_exp"><a href="#val-of_exp" class="anchor"></a><code><span class="keyword">val</span> of_exp : <span>?&#8288;ctyp:<a href="../../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span class="keyword">val</span> of_var : <span>?&#8288;ctyp:<a href="../../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span class="keyword">val</span> of_reg : <span>?&#8288;ctyp:<a href="../../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../index.html#type-id">id</a> <span>&#45;&gt;</span> <a href="../../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span class="keyword">val</span> map_exp : <span>(<a href="../index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="../index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span class="keyword">val</span> iter_exp : <span>(<a href="../index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-exp"><a href="#val-exp" class="anchor"></a><code><span class="keyword">val</span> exp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-ctyp"><a href="#val-ctyp" class="anchor"></a><code><span class="keyword">val</span> ctyp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="../../../Ctype/index.html#type-t">Ctype.t</a> option</span></code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Tval (read-dwarf.State.Base.Tval)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Tval</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Tval</span></code></h1><p>Module for optionally typed state expressions. Those are symbolic values which may or may not have a C type.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.ctyp" class="def record field anchored"><a href="#type-t.ctyp" class="anchor"></a><code><span>ctyp : <span><a href="../../../Ctype/index.html#type-t">Ctype.t</a> option</span>;</span></code></li><li id="type-t.exp" class="def record field anchored"><a href="#type-t.exp" class="anchor"></a><code><span>exp : <a href="../index.html#type-exp">exp</a>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?ctyp</span>:<a href="../../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Make a new typed value with optionally a <a href="../../../Ctype/index.html"><code>Ctype</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_exp"><a href="#val-of_exp" class="anchor"></a><code><span><span class="keyword">val</span> of_exp : <span><span class="optlabel">?ctyp</span>:<a href="../../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span><span class="keyword">val</span> of_var : <span><span class="optlabel">?ctyp</span>:<a href="../../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span><span class="keyword">val</span> of_reg : <span><span class="optlabel">?ctyp</span>:<a href="../../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-id">id</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span><span class="keyword">val</span> map_exp : <span><span>(<span><a href="../index.html#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> iter_exp : <span><span>(<span><a href="../index.html#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp"><a href="#val-exp" class="anchor"></a><code><span><span class="keyword">val</span> exp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ctyp"><a href="#val-ctyp" class="anchor"></a><code><span><span class="keyword">val</span> ctyp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../Ctype/index.html#type-t">Ctype.t</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/Var/index.html b/doc/html/read-dwarf/State/Base/Var/index.html
index 397ee98f..12183a09 100644
--- a/doc/html/read-dwarf/State/Base/Var/index.html
+++ b/doc/html/read-dwarf/State/Base/Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.State.Base.Var)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Var</nav><h1>Module <code>Base.Var</code></h1><p>This module provide state variables. Those are all symbolic variables that may appear in a state. If the same (in the <a href="index.html#val-equal"><code>Var.equal</code></a> sense) variable appear in two state, that mean that when considered together, there is an implicit relation between them.</p><p>This means that the set of pair of concrete states represented by a pair of symbolic state could be a strict subset of the Cartesian product of the sets of concrete state represented by each symbolic state individually.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.Register" class="anchored"><td class="def constructor"><a href="#type-t.Register" class="anchor"></a><code>| </code><code><span class="constructor">Register</span> <span class="keyword">of</span> <a href="../index.html#type-id">id</a> * <a href="../../Reg/index.html#type-t">Reg.t</a></code></td><td class="doc"><p>The value of this register in this state</p></td></tr><tr id="type-t.ReadVar" class="anchored"><td class="def constructor"><a href="#type-t.ReadVar" class="anchor"></a><code>| </code><code><span class="constructor">ReadVar</span> <span class="keyword">of</span> <a href="../index.html#type-id">id</a> * int * <a href="../../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></code></td><td class="doc"><p>The result of a certain read in a certain state. The size part is not semantically important: Two <code>ReadVar</code> with same <code>id</code> and same number may no have different sizes</p></td></tr><tr id="type-t.Arg" class="anchored"><td class="def constructor"><a href="#type-t.Arg" class="anchor"></a><code>| </code><code><span class="constructor">Arg</span> <span class="keyword">of</span> int</code></td><td class="doc"><p>A function argument</p></td></tr><tr id="type-t.RetArg" class="anchored"><td class="def constructor"><a href="#type-t.RetArg" class="anchor"></a><code>| </code><code><span class="constructor">RetArg</span></code></td><td class="doc"><p>The address to which the return value should be written. This is used only in certain calling conventions</p></td></tr><tr id="type-t.RetAddr" class="anchored"><td class="def constructor"><a href="#type-t.RetAddr" class="anchor"></a><code>| </code><code><span class="constructor">RetAddr</span></code></td><td class="doc"><p>The return address: The address to which a &quot;return&quot; instruction would jump.</p></td></tr><tr id="type-t.NonDet" class="anchored"><td class="def constructor"><a href="#type-t.NonDet" class="anchor"></a><code>| </code><code><span class="constructor">NonDet</span> <span class="keyword">of</span> int * <a href="../../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></code></td><td class="doc"><p>Variable representing non-determinism in the spec. Can only be a bit-vector for now.</p></td></tr></table></dt><dd><p>The type of a variable in the state</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert the variable to the string encoding. For parsing infrastructure reason, the encoding must always contain at least one <code>:</code>.</p></dd></dl><dl><dt class="spec value" id="val-expect_register"><a href="#val-expect_register" class="anchor"></a><code><span class="keyword">val</span> expect_register : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Reg/index.html#type-t">Reg.t</a></code></dt><dd><p>Expect a register variable and return the corresponding register. Throw otherwise.</p></dd></dl><dl><dt class="spec value" id="val-expect_readvar"><a href="#val-expect_readvar" class="anchor"></a><code><span class="keyword">val</span> expect_readvar : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Expect a read variable and return the corresponding index. Throw otherwise.</p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>The opposite of <a href="index.html#val-to_string"><code>to_string</code></a>. Will raise <code>Invalid_argument</code> when the string don't match</p></dd></dl><dl><dt class="spec value" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span class="keyword">val</span> of_reg : <a href="../index.html#type-id">id</a> <span>&#45;&gt;</span> <a href="../../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a register variable bound to the provided state id and register</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Hashing function for variable. For now it's polymorphic but this may stop at any time</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Basically <code>to_string</code> in pp mode</p></dd></dl><dl><dt class="spec value" id="val-pp_bar"><a href="#val-pp_bar" class="anchor"></a><code><span class="keyword">val</span> pp_bar : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty prints but with bars around</p></dd></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Reg/index.html#type-ty">Reg.ty</a></code></dt><dd><p>Get the type of a variable</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.State.Base.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Var</span></code></h1><p>This module provide state variables. Those are all symbolic variables that may appear in a state. If the same (in the <a href="#val-equal"><code>Var.equal</code></a> sense) variable appear in two state, that mean that when considered together, there is an implicit relation between them.</p><p>This means that the set of pair of concrete states represented by a pair of symbolic state could be a strict subset of the Cartesian product of the sets of concrete state represented by each symbolic state individually.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.Register" class="def variant constructor anchored"><a href="#type-t.Register" class="anchor"></a><code><span>| </span><span><span class="constructor">Register</span> <span class="keyword">of</span> <a href="../index.html#type-id">id</a> * <a href="../../Reg/index.html#type-t">Reg.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The value of this register in this state</p><span class="comment-delim">*)</span></div></li><li id="type-t.ReadVar" class="def variant constructor anchored"><a href="#type-t.ReadVar" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadVar</span> <span class="keyword">of</span> <a href="../index.html#type-id">id</a> * int * <a href="../../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The result of a certain read in a certain state. The size part is not semantically important: Two <code>ReadVar</code> with same <code>id</code> and same number may no have different sizes</p><span class="comment-delim">*)</span></div></li><li id="type-t.Arg" class="def variant constructor anchored"><a href="#type-t.Arg" class="anchor"></a><code><span>| </span><span><span class="constructor">Arg</span> <span class="keyword">of</span> int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>A function argument</p><span class="comment-delim">*)</span></div></li><li id="type-t.RetArg" class="def variant constructor anchored"><a href="#type-t.RetArg" class="anchor"></a><code><span>| </span><span><span class="constructor">RetArg</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The address to which the return value should be written. This is used only in certain calling conventions</p><span class="comment-delim">*)</span></div></li><li id="type-t.RetAddr" class="def variant constructor anchored"><a href="#type-t.RetAddr" class="anchor"></a><code><span>| </span><span><span class="constructor">RetAddr</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The return address: The address to which a &quot;return&quot; instruction would jump.</p><span class="comment-delim">*)</span></div></li><li id="type-t.NonDet" class="def variant constructor anchored"><a href="#type-t.NonDet" class="anchor"></a><code><span>| </span><span><span class="constructor">NonDet</span> <span class="keyword">of</span> int * <a href="../../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Variable representing non-determinism in the spec. Can only be a bit-vector for now.</p><span class="comment-delim">*)</span></div></li><li id="type-t.Section" class="def variant constructor anchored"><a href="#type-t.Section" class="anchor"></a><code><span>| </span><span><span class="constructor">Section</span> <span class="keyword">of</span> string</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Symbolic base address of ELF section. Assume 64bit for now.</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The type of a variable in the state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert the variable to the string encoding. For parsing infrastructure reason, the encoding must always contain at least one <code>:</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_register"><a href="#val-expect_register" class="anchor"></a><code><span><span class="keyword">val</span> expect_register : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Reg/index.html#type-t">Reg.t</a></span></code></div><div class="spec-doc"><p>Expect a register variable and return the corresponding register. Throw otherwise.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_readvar"><a href="#val-expect_readvar" class="anchor"></a><code><span><span class="keyword">val</span> expect_readvar : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Expect a read variable and return the corresponding index. Throw otherwise.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The opposite of <a href="#val-to_string"><code>to_string</code></a>. Will raise <code>Invalid_argument</code> when the string don't match</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span><span class="keyword">val</span> of_reg : <span><a href="../index.html#type-id">id</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a register variable bound to the provided state id and register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Hashing function for variable. For now it's polymorphic but this may stop at any time</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Basically <code>to_string</code> in pp mode</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_bar"><a href="#val-pp_bar" class="anchor"></a><code><span><span class="keyword">val</span> pp_bar : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints but with bars around</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Reg/index.html#type-ty">Reg.ty</a></span></code></div><div class="spec-doc"><p>Get the type of a variable</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-new_nondet"><a href="#val-new_nondet" class="anchor"></a><code><span><span class="keyword">val</span> new_nondet : <span><a href="../../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get a fresh NonDet variable</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Base/index.html b/doc/html/read-dwarf/State/Base/index.html
index c943f564..c0f4fc1a 100644
--- a/doc/html/read-dwarf/State/Base/index.html
+++ b/doc/html/read-dwarf/State/Base/index.html
@@ -1,2 +1,14 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.State.Base)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Base</nav><h1>Module <code>State.Base</code></h1><p>This module introduce a type to represent the state of the machine.</p><p>The symbolic state in this module do not mathematically represent a single state but a set of concrete state with all the symbolic variable over the whole range of their types. State also contain assertions, and so only represent the subset of concrete states, that satisfy all assertions.</p><p>Currently the state type only represent the register (including system register) and sequential memory part of an actual machine state. Any other architectural state is not represented.</p><p>Additionally, state contain C type information for the <a href="../../Ctype/index.html"><code>Ctype</code></a> inference system. Those fields are not semantically part of the state and do not influence in any way which concrete states are represented by the symbolic state. Expect for provenance information: Pointers can be tagged with provenance information which mean that they are part of a specific restricted block of memory or the main block. See <a href="Mem/index.html"><code>Mem</code></a> for more information. Thus all the implicit non-aliasing assertion implied by those provenance field are to be considered as part of the group of assertion restricting the set of concrete state represented by a symbolic state.</p><p>The presence of C types is optional, which means that this state type can be used in a completely untyped context.</p><p>Concrete detail about how symbolic state are represented in Ocaml is in the documentation of <a href="index.html#type-t"><code>t</code></a>.</p><nav class="toc"><ul><li><a href="#state-id">State id</a></li><li><a href="#state-variable-management">State variable management</a></li><li><a href="#state-expression-and-typed-value-management">State expression and typed-value management</a></li><li><a href="#state-memory-management">State memory management</a></li><li><a href="#state-type">State type</a></li><li><a href="#stateid">State to id management</a></li><li><a href="#state-management">State management</a></li><li><a href="#state-convenience-manipulation">State convenience manipulation</a></li><li><a href="#state-memory-accessors">State memory accessors</a></li><li><a href="#state-register-accessors">State register accessors</a></li><li><a href="#pc-manipulation">Pc manipulation</a></li><li><a href="#pretty-printing">Pretty printing</a></li></ul></nav></header><section><header><h2 id="state-id"><a href="#state-id" class="anchor"></a>State id</h2></header><dl><dt class="spec module" id="module-Id"><a href="#module-Id" class="anchor"></a><code><span class="keyword">module</span> <a href="Id/index.html">Id</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The type of a state ID. for now it's an integer, but it may change later In particular whether a state belong to O0 or O2 may be part of the <code>id</code> at some point.</p></dd></dl><dl><dt class="spec type" id="type-id"><a href="#type-id" class="anchor"></a><code><span class="keyword">type</span> id</code><code> = <a href="Id/index.html#type-t">Id.t</a></code></dt></dl></section><section><header><h2 id="state-variable-management"><a href="#state-variable-management" class="anchor"></a>State variable management</h2></header><dl><dt class="spec module" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span class="keyword">module</span> <a href="Var/index.html">Var</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide state variables. Those are all symbolic variables that may appear in a state. If the same (in the <a href="Var/index.html#val-equal"><code>Var.equal</code></a> sense) variable appear in two state, that mean that when considered together, there is an implicit relation between them.</p></dd></dl><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="Var/index.html#type-t">Var.t</a></code></dt><dd><p>The type of variables</p></dd></dl></section><section><header><h2 id="state-expression-and-typed-value-management"><a href="#state-expression-and-typed-value-management" class="anchor"></a>State expression and typed-value management</h2></header><dl><dt class="spec module" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span class="keyword">module</span> <a href="Exp/index.html">Exp</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Module for state expressions</p></dd></dl><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <a href="Exp/index.html#type-t">Exp.t</a></code></dt></dl><dl><dt class="spec module" id="module-Tval"><a href="#module-Tval" class="anchor"></a><code><span class="keyword">module</span> <a href="Tval/index.html">Tval</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Module for optionally typed state expressions. Those are symbolic values which may or may not have a C type.</p></dd></dl><dl><dt class="spec type" id="type-tval"><a href="#type-tval" class="anchor"></a><code><span class="keyword">type</span> tval</code><code> = <a href="Tval/index.html#type-t">Tval.t</a></code></dt></dl></section><section><header><h2 id="state-memory-management"><a href="#state-memory-management" class="anchor"></a>State memory management</h2></header><dl><dt class="spec module" id="module-Mem"><a href="#module-Mem" class="anchor"></a><code><span class="keyword">module</span> <a href="Mem/index.html">Mem</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module manages the memory part of the state.</p></dd></dl></section><section><header><h2 id="state-type"><a href="#state-type" class="anchor"></a>State type</h2></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span class="keyword">private</span> </code><code>{</code><table class="record"><tr id="type-t.id" class="anchored"><td class="def field"><a href="#type-t.id" class="anchor"></a><code>id : <a href="index.html#type-id">id</a>;</code></td></tr><tr id="type-t.base_state" class="anchored"><td class="def field"><a href="#type-t.base_state" class="anchor"></a><code>base_state : <span><a href="index.html#type-t">t</a> option</span>;</code></td><td class="doc"><p>The immediate dominator state in the control flow graph</p></td></tr><tr id="type-t.locked" class="anchored"><td class="def field"><a href="#type-t.locked" class="anchor"></a><code><span class="keyword">mutable</span> locked : bool;</code></td><td class="doc"><p>Tells if the state is locked</p></td></tr><tr id="type-t.regs" class="anchored"><td class="def field"><a href="#type-t.regs" class="anchor"></a><code><span class="keyword">mutable</span> regs : <span><a href="Tval/index.html#type-t">Tval.t</a> <a href="../Reg/Map/index.html#type-t">Reg.Map.t</a></span>;</code></td><td class="doc"><p>The values and types of registers</p></td></tr><tr id="type-t.read_vars" class="anchored"><td class="def field"><a href="#type-t.read_vars" class="anchor"></a><code>read_vars : <span><a href="Tval/index.html#type-t">Tval.t</a> <a href="../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</code></td><td class="doc"><p>The results of reads made since base state</p></td></tr><tr id="type-t.asserts" class="anchored"><td class="def field"><a href="#type-t.asserts" class="anchor"></a><code><span class="keyword">mutable</span> asserts : <span><a href="index.html#type-exp">exp</a> list</span>;</code></td><td class="doc"><p>Only asserts since base_state</p></td></tr><tr id="type-t.mem" class="anchored"><td class="def field"><a href="#type-t.mem" class="anchor"></a><code>mem : <a href="Mem/index.html#type-t">Mem.t</a>;</code></td></tr><tr id="type-t.elf" class="anchored"><td class="def field"><a href="#type-t.elf" class="anchor"></a><code>elf : <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> option</span>;</code></td><td class="doc"><p>Optionally an ELF file, this may be used when running instructions on the state to provide more concrete values in certain case (like when reading from <code>.rodata</code>). It will affect the execution behavior. However the symbolic execution should always be more concrete with it than without it</p></td></tr><tr id="type-t.fenv" class="anchored"><td class="def field"><a href="#type-t.fenv" class="anchor"></a><code>fenv : <a href="../Fragment/index.html#type-env">Fragment.env</a>;</code></td><td class="doc"><p>The memory type environment. See <a href="../Fragment/index.html#type-env"><code>Fragment.env</code></a></p></td></tr><tr id="type-t.last_pc" class="anchored"><td class="def field"><a href="#type-t.last_pc" class="anchor"></a><code><span class="keyword">mutable</span> last_pc : int;</code></td><td class="doc"><p>The PC of the instruction that lead into this state. The state should be right after that instruction. This has no semantic meaning as part of the state. It's just for helping knowing what comes from where</p></td></tr></table><code>}</code></dt><dd><p>Represent the state of the machine.</p><p>State are represented by their id and may identified to their id, they may not be two different state (and I mean physical equality here) with same id. See <a href="index.html#stateid"><span>State to id management</span></a>.</p><p>A first remark must be made about mutability: The type itself has an imperative interface, a lot of implicitly or explicitly mutable fields. However, Sometime immutable version of the state are required, so the state has a &quot;locking&quot; mechanism. When the <a href="index.html#type-t.locked"><code>locked</code></a> field, the state becomes immutable. This is unfortunately not enforced by the type system as that would require to have two different types. However all mutating functions assert that the state is unlocked before doing the mutation. The normal workflow with state is thus to create them unlocked, generaly by <a href="index.html#val-copy"><code>copy</code></a>ing another state, then mutate is to make a new interesting state, and then lock it so that it can be passed around for it's mathematical pure meaning. To lock a state, use the <a href="index.html#val-lock"><code>lock</code></a> function.</p><p>A second subtlety is that state are not represented in a standalone manner, They are represented as diff from a previous state, the <a href="index.html#type-t.base_state"><code>base_state</code></a>. In the idea, this state should be the immediate dominator of the current state in the control flow graph.However a state may not represent a full node of the control flow graph but only the part of that node that represent control-flow coming from specific paths. In that case the dominator notion is only about those paths.</p><p>Assertions (<a href="index.html#type-t.asserts"><code>asserts</code></a>) and memory (<a href="index.html#type-t.mem"><code>mem</code></a>) are represented as diffs from the base state. In particular all assertion constraining the base state are still constraining the child state.</p><p>This also implies a restriction on state dependent variables like <a href="Var/index.html#type-t.Register"><code>Var.t.Register</code></a>. The id of such variables can only be the id of the current state or one of it's ancestor. Further more if a variable of type <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> exists with and id and a number, then the <a href="index.html#type-t.read_vars"><code>read_vars</code></a> array of the state with that <code>id</code> must contain that number and the sizes must match. Those restriction are not only about semantic meaning but also more practical Ocaml Gc consideration, see <a href="index.html#stateid"><span>State to id management</span></a>.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt></dl></section><section><header><h2 id="stateid"><a href="#stateid" class="anchor"></a>State to id management</h2><p>Each state has an id and the state can be refereed physically by id. This mean that there cannot be two different physical Ocaml state in the Gc memory that have the same id. Furthermore the <a href="index.html#val-id2state"><code>id2state</code></a> map is weak and so do not own the state. This means that possession of an id is the same as having a weak pointer to the state, except for two things:</p><ul><li>The id can be serialized and read to external program and files without losing it's meaning.</li><li>The id allow to break cyclical type dependency.</li></ul><p>This is in particular useful for variable that contain and id instead of a pointer to the state:</p><ul><li>The variable can be serialized in text manner to a SMT solver and keep their meaning.</li><li>The <a href="Var/index.html#type-t"><code>Var.t</code></a> type can be defined before the <a href="index.html#type-t"><code>t</code></a> type.</li></ul><p>That means that in theory a state could be Garbage collected while a variable still point to it. However a variable is only allowed to exists in a state if the id it points to is among the ancestors via the <a href="index.html#type-t.base_state"><code>base_state</code></a> relationship of the containing state. Since <a href="index.html#type-t.base_state"><code>base_state</code></a> is an GC-owning pointer, this ensure that while the containing state is alive, the variable target state is also alive.</p></header><dl><dt class="spec value" id="val-id2state"><a href="#val-id2state" class="anchor"></a><code><span class="keyword">val</span> id2state : <span><span>(<a href="index.html#type-id">id</a>, <a href="index.html#type-t">t</a>)</span> <a href="../../Utils/WeakMap/index.html#type-t">Utils.WeakMap.t</a></span></code></dt><dd><p>Global map of states to associate them with identifiers</p></dd></dl><dl><dt class="spec value" id="val-next_id"><a href="#val-next_id" class="anchor"></a><code><span class="keyword">val</span> next_id : <span><a href="index.html#type-id">id</a> Stdlib.ref</span></code></dt><dd><p>Next unused id</p></dd></dl><dl><dt class="spec value" id="val-of_id"><a href="#val-of_id" class="anchor"></a><code><span class="keyword">val</span> of_id : <a href="index.html#type-id">id</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get a state from its <code>id</code></p></dd></dl><dl><dt class="spec value" id="val-to_id"><a href="#val-to_id" class="anchor"></a><code><span class="keyword">val</span> to_id : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-id">id</a></code></dt><dd><p>Get the id of a state</p></dd></dl></section><section><header><h2 id="state-management"><a href="#state-management" class="anchor"></a>State management</h2></header><dl><dt class="spec value" id="val-lock"><a href="#val-lock" class="anchor"></a><code><span class="keyword">val</span> lock : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Lock the state. Once a state is locked it should not be mutated anymore</p></dd></dl><dl><dt class="spec value" id="val-unsafe_unlock"><a href="#val-unsafe_unlock" class="anchor"></a><code><span class="keyword">val</span> unsafe_unlock : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Unlock the state. This is dangerous, do not use if you do not know how to use it, The only realistic use case, is for calling a simplifier and thus not changing the semantic meaning of the state in any way while mutating it.</p><p>This is deprecated and should disappear at some point.</p></dd></dl><dl><dt class="spec value" id="val-is_locked"><a href="#val-is_locked" class="anchor"></a><code><span class="keyword">val</span> is_locked : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if the state is locked, in which case it shouldn't be mutated</p></dd></dl><dl><dt class="spec value" id="val-is_possible"><a href="#val-is_possible" class="anchor"></a><code><span class="keyword">val</span> is_possible : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell is state is possible.</p><p>A state is impossible if it has a single assert that is <code>false</code>. This means that this symbolic state represent the empty set of concrete states.</p><p><span class="xref-unresolved" title="unresolved reference to &quot;StateSimplify.ctxfull&quot;"><code>StateSimplify</code>.ctxfull</span> will call the SMT solver and set the assertions to that if required so you should call that function before <code>is_possible</code></p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;elf:<a href="../../Elf/File/index.html#type-t">Elf.File.t</a></span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Makes a fresh state with all variable fresh and new. This fresh state is unlocked.</p><p>This should only be used by <code>Init</code>, all other state should be derived from <span class="xref-unresolved" title="unresolved reference to &quot;Init.state&quot;"><code>Init</code>.state</span>.</p></dd></dl><dl><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span>?&#8288;elf:<a href="../../Elf/File/index.html#type-t">Elf.File.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Do a deep copy of all the mutable part of the state, so it can be mutated without retro-action.</p><p>If the source state is locked, then new state is based on it (in the sense of <a href="index.html#type-t.base_state"><code>t.base_state</code></a>), otherwise it is a literal copy of each field.</p><p>The returned state is always unlocked</p></dd></dl><dl><dt class="spec value" id="val-copy_if_locked"><a href="#val-copy_if_locked" class="anchor"></a><code><span class="keyword">val</span> copy_if_locked : <span>?&#8288;elf:<a href="../../Elf/File/index.html#type-t">Elf.File.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Copy the state with <a href="index.html#val-copy"><code>copy</code></a> if and only if it is locked. The returned state is always unlocked</p></dd></dl></section><section><header><h2 id="state-convenience-manipulation"><a href="#state-convenience-manipulation" class="anchor"></a>State convenience manipulation</h2></header><dl><dt class="spec value" id="val-push_assert"><a href="#val-push_assert" class="anchor"></a><code><span class="keyword">val</span> push_assert : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add an assertion to a state</p></dd></dl><dl><dt class="spec value" id="val-set_impossible"><a href="#val-set_impossible" class="anchor"></a><code><span class="keyword">val</span> set_impossible : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a state to be impossible (single <code>false</code> assert).</p></dd></dl><dl><dt class="spec value" id="val-set_asserts"><a href="#val-set_asserts" class="anchor"></a><code><span class="keyword">val</span> set_asserts : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a state's <code>asserts</code></p></dd></dl><dl><dt class="spec value" id="val-map_mut_exp"><a href="#val-map_mut_exp" class="anchor"></a><code><span class="keyword">val</span> map_mut_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map a function on all the expressions of a state by mutating. This function, must preserve the semantic meaning of expression (like a simplification function) otherwise state invariants may be broken.</p></dd></dl><dl><dt class="spec value" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span class="keyword">val</span> iter_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterates a function on all the expressions of a state</p></dd></dl><dl><dt class="spec value" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span class="keyword">val</span> iter_var : <span>(<a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterates a function on all the variables of a state</p></dd></dl></section><section><header><h2 id="state-memory-accessors"><a href="#state-memory-accessors" class="anchor"></a>State memory accessors</h2></header><dl><dt class="spec value" id="val-make_read"><a href="#val-make_read" class="anchor"></a><code><span class="keyword">val</span> make_read : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>?&#8288;ctyp:<a href="../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a></code></dt><dd><p>Create a new <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> by mutating the state</p></dd></dl><dl><dt class="spec value" id="val-set_read"><a href="#val-set_read" class="anchor"></a><code><span class="keyword">val</span> set_read : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> to a specific value in <a href="index.html#type-t.read_vars"><code>t.read_vars</code></a></p></dd></dl><dl><dt class="spec value" id="val-read_from_rodata"><a href="#val-read_from_rodata" class="anchor"></a><code><span class="keyword">val</span> read_from_rodata : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> option</span></code></dt><dd><p>Read memory from rodata</p></dd></dl><dl><dt class="spec value" id="val-read"><a href="#val-read" class="anchor"></a><code><span class="keyword">val</span> read : <span>provenance:<a href="../../Ctype/index.html#type-provenance">Ctype.provenance</a></span> <span>&#45;&gt;</span> <span>?&#8288;ctyp:<a href="../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Read the block designated by <code>addr</code> and <code>size</code> from the state and return an expression read. This will mutate the state to bind the read result to the newly created read variable.</p><p>The <code>ctyp</code> parameter may give a type to the read variable. This type is fully trusted and not checked in any way.</p><p>The expression could be either:</p><ul><li>An actual expression if the read could be resolved.</li><li>Just the symbolic read variable if the read couldn't be resolved</li></ul><p>This function is for case with <code>provenance</code> information is known.</p></dd></dl><dl><dt class="spec value" id="val-read_noprov"><a href="#val-read_noprov" class="anchor"></a><code><span class="keyword">val</span> read_noprov : <span>?&#8288;ctyp:<a href="../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>A wrapper around <a href="index.html#val-read"><code>read</code></a> for use when there is no provenance information. It may able to still perform the read under certain condition and otherwise will fail.</p></dd></dl><dl><dt class="spec value" id="val-write"><a href="#val-write" class="anchor"></a><code><span class="keyword">val</span> write : <span>provenance:<a href="../../Ctype/index.html#type-provenance">Ctype.provenance</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write the provided value in the block. Mutate the state.</p></dd></dl><dl><dt class="spec value" id="val-write_noprov"><a href="#val-write_noprov" class="anchor"></a><code><span class="keyword">val</span> write_noprov : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>A wrapper around <a href="index.html#val-write"><code>write</code></a> for use when there is no provenance information. It may able to still perform the write under certain condition and otherwise will fail.</p></dd></dl></section><section><header><h2 id="state-register-accessors"><a href="#state-register-accessors" class="anchor"></a>State register accessors</h2></header><dl><dt class="spec value" id="val-reset_reg"><a href="#val-reset_reg" class="anchor"></a><code><span class="keyword">val</span> reset_reg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>?&#8288;ctyp:<a href="../../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Reset the register to a symbolic value, and resets the type to the provided type (or no type if not provided)</p></dd></dl><dl><dt class="spec value" id="val-set_reg"><a href="#val-set_reg" class="anchor"></a><code><span class="keyword">val</span> set_reg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-tval">tval</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Sets the content of register</p></dd></dl><dl><dt class="spec value" id="val-set_reg_type"><a href="#val-set_reg_type" class="anchor"></a><code><span class="keyword">val</span> set_reg_type : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="../../Ctype/index.html#type-t">Ctype.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Sets the type of the register, leaves the value unchanged</p></dd></dl><dl><dt class="spec value" id="val-get_reg"><a href="#val-get_reg" class="anchor"></a><code><span class="keyword">val</span> get_reg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-tval">tval</a></code></dt><dd><p>Get the content of the register with it's type</p></dd></dl><dl><dt class="spec value" id="val-get_reg_exp"><a href="#val-get_reg_exp" class="anchor"></a><code><span class="keyword">val</span> get_reg_exp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Get the content of the register without it's type</p></dd></dl><dl><dt class="spec value" id="val-update_reg_exp"><a href="#val-update_reg_exp" class="anchor"></a><code><span class="keyword">val</span> update_reg_exp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Apply a function to a register. Leave the type intact</p></dd></dl></section><section><header><h2 id="pc-manipulation"><a href="#pc-manipulation" class="anchor"></a>Pc manipulation</h2></header><dl><dt class="spec value" id="val-set_pc"><a href="#val-set_pc" class="anchor"></a><code><span class="keyword">val</span> set_pc : <span>pc:<a href="../Reg/index.html#type-t">Reg.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the PC to a concrete value and keep its type appropriate</p></dd></dl><dl><dt class="spec value" id="val-bump_pc"><a href="#val-bump_pc" class="anchor"></a><code><span class="keyword">val</span> bump_pc : <span>pc:<a href="../Reg/index.html#type-t">Reg.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Bump a concrete PC by a concrete bump (generally the size of a non-branching instruction</p></dd></dl><dl><dt class="spec value" id="val-concretize_pc"><a href="#val-concretize_pc" class="anchor"></a><code><span class="keyword">val</span> concretize_pc : <span>pc:<a href="../Reg/index.html#type-t">Reg.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Try to evaluate the PC if it is concrete</p></dd></dl><dl><dt class="spec value" id="val-set_last_pc"><a href="#val-set_last_pc" class="anchor"></a><code><span class="keyword">val</span> set_last_pc : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the <code>last_pc</code> of the state</p></dd></dl></section><section><header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2></header><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_partial"><a href="#val-pp_partial" class="anchor"></a><code><span class="keyword">val</span> pp_partial : <span>regs:<span><a href="../Reg/index.html#type-t">Reg.t</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Print only the mentioned regs and the memory and asserts since the base_state. Until a better solution is found, the fenv will be printed entirely all the time</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.State.Base)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Base</nav><header class="odoc-preamble"><h1>Module <code><span>State.Base</span></code></h1><p>This module introduce a type to represent the state of the machine.</p><p>The symbolic state in this module do not mathematically represent a single state but a set of concrete state with all the symbolic variable over the whole range of their types. State also contain assertions, and so only represent the subset of concrete states, that satisfy all assertions.</p><p>Currently the state type only represent the register (including system register) and sequential memory part of an actual machine state. Any other architectural state is not represented.</p><p>Additionally, state contain C type information for the <a href="../../Ctype/index.html"><code>Ctype</code></a> inference system. Those fields are not semantically part of the state and do not influence in any way which concrete states are represented by the symbolic state. Expect for provenance information: Pointers can be tagged with provenance information which mean that they are part of a specific restricted block of memory or the main block. See <a href="Mem/index.html"><code>Mem</code></a> for more information. Thus all the implicit non-aliasing assertion implied by those provenance field are to be considered as part of the group of assertion restricting the set of concrete state represented by a symbolic state.</p><p>The presence of C types is optional, which means that this state type can be used in a completely untyped context.</p><p>Concrete detail about how symbolic state are represented in Ocaml is in the documentation of <a href="#type-t"><code>t</code></a>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#state-id">State id</a></li><li><a href="#state-variable-management">State variable management</a></li><li><a href="#state-expression-and-typed-value-management">State expression and typed-value management</a></li><li><a href="#state-memory-management">State memory management</a></li><li><a href="#state-type">State type</a></li><li><a href="#stateid">State to id management</a></li><li><a href="#state-management">State management</a></li><li><a href="#state-convenience-manipulation">State convenience manipulation</a></li><li><a href="#state-memory-accessors">State memory accessors</a></li><li><a href="#state-register-accessors">State register accessors</a></li><li><a href="#pc-manipulation">Pc manipulation</a></li><li><a href="#pretty-printing">Pretty printing</a></li></ul></nav></div><div class="odoc-content"><h2 id="state-id"><a href="#state-id" class="anchor"></a>State id</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Id"><a href="#module-Id" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Id/index.html">Id</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The type of a state ID. for now it's an integer, but it may change later In particular whether a state belong to O0 or O2 may be part of the <code>id</code> at some point.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-id"><a href="#type-id" class="anchor"></a><code><span><span class="keyword">type</span> id</span><span> = <a href="Id/index.html#type-t">Id.t</a></span></code></div></div><h2 id="state-variable-management"><a href="#state-variable-management" class="anchor"></a>State variable management</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Var/index.html">Var</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide state variables. Those are all symbolic variables that may appear in a state. If the same (in the <a href="Var/index.html#val-equal"><code>Var.equal</code></a> sense) variable appear in two state, that mean that when considered together, there is an implicit relation between them.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="Var/index.html#type-t">Var.t</a></span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><h2 id="state-expression-and-typed-value-management"><a href="#state-expression-and-typed-value-management" class="anchor"></a>State expression and typed-value management</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Exp/index.html">Exp</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Module for state expressions</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <a href="Exp/index.html#type-t">Exp.t</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Tval"><a href="#module-Tval" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Tval/index.html">Tval</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Module for optionally typed state expressions. Those are symbolic values which may or may not have a C type.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tval"><a href="#type-tval" class="anchor"></a><code><span><span class="keyword">type</span> tval</span><span> = <a href="Tval/index.html#type-t">Tval.t</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Relocation"><a href="#module-Relocation" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Relocation/index.html">Relocation</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><h2 id="state-memory-management"><a href="#state-memory-management" class="anchor"></a>State memory management</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Mem"><a href="#module-Mem" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Mem/index.html">Mem</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module manages the memory part of the state.</p></div></div><h2 id="state-type"><a href="#state-type" class="anchor"></a>State type</h2><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span class="keyword">private</span> </span><span>{</span></code><ol><li id="type-t.id" class="def record field anchored"><a href="#type-t.id" class="anchor"></a><code><span>id : <a href="#type-id">id</a>;</span></code></li><li id="type-t.base_state" class="def record field anchored"><a href="#type-t.base_state" class="anchor"></a><code><span>base_state : <span><a href="#type-t">t</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The immediate dominator state in the control flow graph</p><span class="comment-delim">*)</span></div></li><li id="type-t.locked" class="def record field anchored"><a href="#type-t.locked" class="anchor"></a><code><span><span class="keyword">mutable</span> locked : bool;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Tells if the state is locked</p><span class="comment-delim">*)</span></div></li><li id="type-t.regs" class="def record field anchored"><a href="#type-t.regs" class="anchor"></a><code><span><span class="keyword">mutable</span> regs : <span><a href="Tval/index.html#type-t">Tval.t</a> <a href="../Reg/Map/index.html#type-t">Reg.Map.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The values and types of registers</p><span class="comment-delim">*)</span></div></li><li id="type-t.read_vars" class="def record field anchored"><a href="#type-t.read_vars" class="anchor"></a><code><span>read_vars : <span><a href="Tval/index.html#type-t">Tval.t</a> <a href="../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The results of reads made since base state</p><span class="comment-delim">*)</span></div></li><li id="type-t.asserts" class="def record field anchored"><a href="#type-t.asserts" class="anchor"></a><code><span><span class="keyword">mutable</span> asserts : <span><a href="#type-exp">exp</a> list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Only asserts since base_state</p><span class="comment-delim">*)</span></div></li><li id="type-t.relocation_asserts" class="def record field anchored"><a href="#type-t.relocation_asserts" class="anchor"></a><code><span><span class="keyword">mutable</span> relocation_asserts : <span><a href="#type-exp">exp</a> list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Only asserts since base_state</p><span class="comment-delim">*)</span></div></li><li id="type-t.mem" class="def record field anchored"><a href="#type-t.mem" class="anchor"></a><code><span>mem : <a href="Mem/index.html#type-t">Mem.t</a>;</span></code></li><li id="type-t.elf" class="def record field anchored"><a href="#type-t.elf" class="anchor"></a><code><span>elf : <span><a href="../../Elf/File/index.html#type-t">Elf.File.t</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Optionally an ELF file, this may be used when running instructions on the state to provide more concrete values in certain case (like when reading from <code>.rodata</code>). It will affect the execution behavior. However the symbolic execution should always be more concrete with it than without it</p><span class="comment-delim">*)</span></div></li><li id="type-t.fenv" class="def record field anchored"><a href="#type-t.fenv" class="anchor"></a><code><span>fenv : <a href="../Fragment/index.html#type-env">Fragment.env</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The memory type environment. See <a href="../Fragment/index.html#type-env"><code>Fragment.env</code></a></p><span class="comment-delim">*)</span></div></li><li id="type-t.last_pc" class="def record field anchored"><a href="#type-t.last_pc" class="anchor"></a><code><span><span class="keyword">mutable</span> last_pc : <a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The PC of the instruction that lead into this state. The state should be right after that instruction. This has no semantic meaning as part of the state. It's just for helping knowing what comes from where</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Represent the state of the machine.</p><p>State are represented by their id and may identified to their id, they may not be two different state (and I mean physical equality here) with same id. See <a href="#stateid" title="stateid">State to id management</a>.</p><p>A first remark must be made about mutability: The type itself has an imperative interface, a lot of implicitly or explicitly mutable fields. However, Sometime immutable version of the state are required, so the state has a &quot;locking&quot; mechanism. When the <a href="#type-t.locked"><code>locked</code></a> field, the state becomes immutable. This is unfortunately not enforced by the type system as that would require to have two different types. However all mutating functions assert that the state is unlocked before doing the mutation. The normal workflow with state is thus to create them unlocked, generaly by <a href="#val-copy"><code>copy</code></a>ing another state, then mutate is to make a new interesting state, and then lock it so that it can be passed around for it's mathematical pure meaning. To lock a state, use the <a href="#val-lock"><code>lock</code></a> function.</p><p>A second subtlety is that state are not represented in a standalone manner, They are represented as diff from a previous state, the <a href="#type-t.base_state"><code>base_state</code></a>. In the idea, this state should be the immediate dominator of the current state in the control flow graph.However a state may not represent a full node of the control flow graph but only the part of that node that represent control-flow coming from specific paths. In that case the dominator notion is only about those paths.</p><p>Assertions (<a href="#type-t.asserts"><code>asserts</code></a>) and memory (<a href="#type-t.mem"><code>mem</code></a>) are represented as diffs from the base state. In particular all assertion constraining the base state are still constraining the child state.</p><p>This also implies a restriction on state dependent variables like <a href="Var/index.html#type-t.Register"><code>Var.t.Register</code></a>. The id of such variables can only be the id of the current state or one of it's ancestor. Further more if a variable of type <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> exists with and id and a number, then the <a href="#type-t.read_vars"><code>read_vars</code></a> array of the state with that <code>id</code> must contain that number and the sizes must match. Those restriction are not only about semantic meaning but also more practical Ocaml Gc consideration, see <a href="#stateid" title="stateid">State to id management</a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><h2 id="stateid"><a href="#stateid" class="anchor"></a>State to id management</h2><p>Each state has an id and the state can be refereed physically by id. This mean that there cannot be two different physical Ocaml state in the Gc memory that have the same id. Furthermore the <a href="#val-id2state"><code>id2state</code></a> map is weak and so do not own the state. This means that possession of an id is the same as having a weak pointer to the state, except for two things:</p><ul><li>The id can be serialized and read to external program and files without losing it's meaning.</li><li>The id allow to break cyclical type dependency.</li></ul><p>This is in particular useful for variable that contain and id instead of a pointer to the state:</p><ul><li>The variable can be serialized in text manner to a SMT solver and keep their meaning.</li><li>The <a href="Var/index.html#type-t"><code>Var.t</code></a> type can be defined before the <a href="#type-t"><code>t</code></a> type.</li></ul><p>That means that in theory a state could be Garbage collected while a variable still point to it. However a variable is only allowed to exists in a state if the id it points to is among the ancestors via the <a href="#type-t.base_state"><code>base_state</code></a> relationship of the containing state. Since <a href="#type-t.base_state"><code>base_state</code></a> is an GC-owning pointer, this ensure that while the containing state is alive, the variable target state is also alive.</p><div class="odoc-spec"><div class="spec value anchored" id="val-id2state"><a href="#val-id2state" class="anchor"></a><code><span><span class="keyword">val</span> id2state : <span><span>(<a href="#type-id">id</a>, <a href="#type-t">t</a>)</span> <a href="../../Utils/WeakMap/index.html#type-t">Utils.WeakMap.t</a></span></span></code></div><div class="spec-doc"><p>Global map of states to associate them with identifiers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-next_id"><a href="#val-next_id" class="anchor"></a><code><span><span class="keyword">val</span> next_id : <span><a href="#type-id">id</a> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>Next unused id</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_id"><a href="#val-of_id" class="anchor"></a><code><span><span class="keyword">val</span> of_id : <span><a href="#type-id">id</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get a state from its <code>id</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_id"><a href="#val-to_id" class="anchor"></a><code><span><span class="keyword">val</span> to_id : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-id">id</a></span></code></div><div class="spec-doc"><p>Get the id of a state</p></div></div><h2 id="state-management"><a href="#state-management" class="anchor"></a>State management</h2><div class="odoc-spec"><div class="spec value anchored" id="val-lock"><a href="#val-lock" class="anchor"></a><code><span><span class="keyword">val</span> lock : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Lock the state. Once a state is locked it should not be mutated anymore</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_unlock"><a href="#val-unsafe_unlock" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_unlock : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Unlock the state. This is dangerous, do not use if you do not know how to use it, The only realistic use case, is for calling a simplifier and thus not changing the semantic meaning of the state in any way while mutating it.</p><p>This is deprecated and should disappear at some point.</p><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> Stop unlocking states</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_locked"><a href="#val-is_locked" class="anchor"></a><code><span><span class="keyword">val</span> is_locked : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if the state is locked, in which case it shouldn't be mutated</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_possible"><a href="#val-is_possible" class="anchor"></a><code><span><span class="keyword">val</span> is_possible : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell is state is possible.</p><p>A state is impossible if it has a single assert that is <code>false</code>. This means that this symbolic state represent the empty set of concrete states.</p><p><code>StateSimplify.ctxfull</code> will call the SMT solver and set the assertions to that if required so you should call that function before <code>is_possible</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?elf</span>:<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Makes a fresh state with all variable fresh and new. This fresh state is unlocked.</p><p>This should only be used by <code>Init</code>, all other state should be derived from <code>Init.state</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span class="optlabel">?elf</span>:<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Do a deep copy of all the mutable part of the state, so it can be mutated without retro-action.</p><p>If the source state is locked, then new state is based on it (in the sense of <a href="#type-t.base_state"><code>t.base_state</code></a>), otherwise it is a literal copy of each field.</p><p>The returned state is always unlocked</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy_if_locked"><a href="#val-copy_if_locked" class="anchor"></a><code><span><span class="keyword">val</span> copy_if_locked : <span><span class="optlabel">?elf</span>:<a href="../../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Copy the state with <a href="#val-copy"><code>copy</code></a> if and only if it is locked. The returned state is always unlocked</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init_sections"><a href="#val-init_sections" class="anchor"></a><code><span><span class="keyword">val</span> init_sections : <span><span class="label">sp</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Reg/index.html#type-t">Reg.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr_size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init_sections_symbolic"><a href="#val-init_sections_symbolic" class="anchor"></a><code><span><span class="keyword">val</span> init_sections_symbolic : <span><span class="label">sp</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../Reg/index.html#type-t">Reg.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr_size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Assigns all sections with global objects to Main fragment</p></div></div><h2 id="state-convenience-manipulation"><a href="#state-convenience-manipulation" class="anchor"></a>State convenience manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-push_assert"><a href="#val-push_assert" class="anchor"></a><code><span><span class="keyword">val</span> push_assert : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add an assertion to a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-push_relocation_assert"><a href="#val-push_relocation_assert" class="anchor"></a><code><span><span class="keyword">val</span> push_relocation_assert : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add an assertion to a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_impossible"><a href="#val-set_impossible" class="anchor"></a><code><span><span class="keyword">val</span> set_impossible : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a state to be impossible (single <code>false</code> assert).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_asserts"><a href="#val-set_asserts" class="anchor"></a><code><span><span class="keyword">val</span> set_asserts : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a state's <code>asserts</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut_exp"><a href="#val-map_mut_exp" class="anchor"></a><code><span><span class="keyword">val</span> map_mut_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map a function on all the expressions of a state by mutating. This function, must preserve the semantic meaning of expression (like a simplification function) otherwise state invariants may be broken.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> iter_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterates a function on all the expressions of a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span><span class="keyword">val</span> iter_var : <span><span>(<span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterates a function on all the variables of a state</p></div></div><h2 id="state-memory-accessors"><a href="#state-memory-accessors" class="anchor"></a>State memory accessors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-make_read"><a href="#val-make_read" class="anchor"></a><code><span><span class="keyword">val</span> make_read : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?ctyp</span>:<a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-var">var</a></span></code></div><div class="spec-doc"><p>Create a new <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> by mutating the state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_read"><a href="#val-set_read" class="anchor"></a><code><span><span class="keyword">val</span> set_read : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> to a specific value in <a href="#type-t.read_vars"><code>t.read_vars</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_from_rodata"><a href="#val-read_from_rodata" class="anchor"></a><code><span><span class="keyword">val</span> read_from_rodata : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:<a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> option</span></span></code></div><div class="spec-doc"><p>Read memory from rodata</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read"><a href="#val-read" class="anchor"></a><code><span><span class="keyword">val</span> read : 
+  <span><span class="label">provenance</span>:<a href="../../Ctype/index.html#type-provenance">Ctype.provenance</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?ctyp</span>:<a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">size</span>:<a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Read the block designated by <code>addr</code> and <code>size</code> from the state and return an expression read. This will mutate the state to bind the read result to the newly created read variable.</p><p>The <code>ctyp</code> parameter may give a type to the read variable. This type is fully trusted and not checked in any way.</p><p>The expression could be either:</p><ul><li>An actual expression if the read could be resolved.</li><li>Just the symbolic read variable if the read couldn't be resolved</li></ul><p>This function is for case with <code>provenance</code> information is known.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_noprov"><a href="#val-read_noprov" class="anchor"></a><code><span><span class="keyword">val</span> read_noprov : <span><span class="optlabel">?ctyp</span>:<a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:<a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>A wrapper around <a href="#val-read"><code>read</code></a> for use when there is no provenance information. It may able to still perform the read under certain condition and otherwise will fail.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write"><a href="#val-write" class="anchor"></a><code><span><span class="keyword">val</span> write : 
+  <span><span class="label">provenance</span>:<a href="../../Ctype/index.html#type-provenance">Ctype.provenance</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">size</span>:<a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Write the provided value in the block. Mutate the state.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_noprov"><a href="#val-write_noprov" class="anchor"></a><code><span><span class="keyword">val</span> write_noprov : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:<a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>A wrapper around <a href="#val-write"><code>write</code></a> for use when there is no provenance information. It may able to still perform the write under certain condition and otherwise will fail.</p></div></div><h2 id="state-register-accessors"><a href="#state-register-accessors" class="anchor"></a>State register accessors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-reset_reg"><a href="#val-reset_reg" class="anchor"></a><code><span><span class="keyword">val</span> reset_reg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?ctyp</span>:<a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Reset the register to a symbolic value, and resets the type to the provided type (or no type if not provided)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_reg"><a href="#val-set_reg" class="anchor"></a><code><span><span class="keyword">val</span> set_reg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-tval">tval</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Sets the content of register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_reg_type"><a href="#val-set_reg_type" class="anchor"></a><code><span><span class="keyword">val</span> set_reg_type : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Sets the type of the register, leaves the value unchanged</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_reg"><a href="#val-get_reg" class="anchor"></a><code><span><span class="keyword">val</span> get_reg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-tval">tval</a></span></code></div><div class="spec-doc"><p>Get the content of the register with it's type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_reg_exp"><a href="#val-get_reg_exp" class="anchor"></a><code><span><span class="keyword">val</span> get_reg_exp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Get the content of the register without it's type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update_reg_exp"><a href="#val-update_reg_exp" class="anchor"></a><code><span><span class="keyword">val</span> update_reg_exp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Apply a function to a register. Leave the type intact</p></div></div><h2 id="pc-manipulation"><a href="#pc-manipulation" class="anchor"></a>Pc manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-set_pc"><a href="#val-set_pc" class="anchor"></a><code><span><span class="keyword">val</span> set_pc : <span><span class="label">pc</span>:<a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the PC to a concrete value and keep its type appropriate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_pc_sym"><a href="#val-set_pc_sym" class="anchor"></a><code><span><span class="keyword">val</span> set_pc_sym : <span><span class="label">pc</span>:<a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bump_pc"><a href="#val-bump_pc" class="anchor"></a><code><span><span class="keyword">val</span> bump_pc : <span><span class="label">pc</span>:<a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Bump a concrete PC by a concrete bump (generally the size of a non-branching instruction</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concretize_pc"><a href="#val-concretize_pc" class="anchor"></a><code><span><span class="keyword">val</span> concretize_pc : <span><span class="label">pc</span>:<a href="../Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Try to evaluate the PC if it is concrete</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_last_pc"><a href="#val-set_last_pc" class="anchor"></a><code><span><span class="keyword">val</span> set_last_pc : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the <code>last_pc</code> of the state</p></div></div><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_partial"><a href="#val-pp_partial" class="anchor"></a><code><span><span class="keyword">val</span> pp_partial : <span><span class="label">regs</span>:<span><a href="../Reg/index.html#type-t">Reg.t</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Print only the mentioned regs and the memory and asserts since the base_state. Until a better solution is found, the fenv will be printed entirely all the time</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Fragment/Env/index.html b/doc/html/read-dwarf/State/Fragment/Env/index.html
index 62f60353..d7bb0a67 100644
--- a/doc/html/read-dwarf/State/Fragment/Env/index.html
+++ b/doc/html/read-dwarf/State/Fragment/Env/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Env (read-dwarf.State.Fragment.Env)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Fragment</a> &#x00BB; Env</nav><h1>Module <code>Fragment.Env</code></h1></header><dl><dt class="spec type" id="type-frag"><a href="#type-frag" class="anchor"></a><code><span class="keyword">type</span> frag</code><code> = <a href="../index.html#type-t">t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.frags" class="anchored"><td class="def field"><a href="#type-t.frags" class="anchor"></a><code>frags : <span><a href="index.html#type-frag">frag</a> <a href="../../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</code></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : unit <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-add_typ"><a href="#val-add_typ" class="anchor"></a><code><span class="keyword">val</span> add_typ : <span>addr:int</span> <span>&#45;&gt;</span> <a href="../../../Ctype/index.html#type-t">Ctype.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>id:int</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add the provided type at <code>addr</code> into a fragment indexed by <code>id</code> in the environment</p></dd></dl><dl><dt class="spec value" id="val-adds_frag"><a href="#val-adds_frag" class="anchor"></a><code><span class="keyword">val</span> adds_frag : <span>?&#8288;frag:<a href="index.html#type-frag">frag</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add a new fragment to the environment. <a href="../index.html#val-empty"><code>empty</code></a> by default.</p></dd></dl><dl><dt class="spec value" id="val-add_frag"><a href="#val-add_frag" class="anchor"></a><code><span class="keyword">val</span> add_frag : <span>?&#8288;frag:<a href="index.html#type-frag">frag</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Add a new fragment to the environment, returns the id of the new fragment. <code>frag</code> is <a href="../index.html#val-empty"><code>empty</code></a> by default.</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-frag">frag</a></code></dt><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-frag">frag</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Env (read-dwarf.State.Fragment.Env)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Fragment</a> &#x00BB; Env</nav><header class="odoc-preamble"><h1>Module <code><span>Fragment.Env</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-frag"><a href="#type-frag" class="anchor"></a><code><span><span class="keyword">type</span> frag</span><span> = <a href="../index.html#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.frags" class="def record field anchored"><a href="#type-t.frags" class="anchor"></a><code><span>frags : <span><a href="#type-frag">frag</a> <a href="../../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_typ"><a href="#val-add_typ" class="anchor"></a><code><span><span class="keyword">val</span> add_typ : <span><span class="label">addr</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">id</span>:int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add the provided type at <code>addr</code> into a fragment indexed by <code>id</code> in the environment</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-adds_frag"><a href="#val-adds_frag" class="anchor"></a><code><span><span class="keyword">val</span> adds_frag : <span><span class="optlabel">?frag</span>:<a href="#type-frag">frag</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add a new fragment to the environment. <a href="../index.html#val-empty"><code>empty</code></a> by default.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_frag"><a href="#val-add_frag" class="anchor"></a><code><span><span class="keyword">val</span> add_frag : <span><span class="optlabel">?frag</span>:<a href="#type-frag">frag</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Add a new fragment to the environment, returns the id of the new fragment. <code>frag</code> is <a href="../index.html#val-empty"><code>empty</code></a> by default.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-frag">frag</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-frag">frag</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Fragment/index.html b/doc/html/read-dwarf/State/Fragment/index.html
index 441bfd7c..2943b6bd 100644
--- a/doc/html/read-dwarf/State/Fragment/index.html
+++ b/doc/html/read-dwarf/State/Fragment/index.html
@@ -1,6 +1,11 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Fragment (read-dwarf.State.Fragment)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Fragment</nav><h1>Module <code>State.Fragment</code></h1><p>This module define a memory fragment to be used by C types</p><nav class="toc"><ul><li><a href="#fragments">Fragments</a></li><li><a href="#environment">Environment</a></li></ul></nav></header><section><header><h2 id="fragments"><a href="#fragments" class="anchor"></a>Fragments</h2></header><div><div class="spec include"><div class="doc"><p><code>obj</code> is just <a href="../../Ctype/index.html#type-t"><code>Ctype.t</code></a>, but a bug in odoc hides that information. <span class="xref-unresolved" title="unresolved reference to &quot;Fragment.obj&quot;"><a href="../index.html#module-Fragment"><code>Fragment</code></a>.obj</span> actually do not exists.</p><p>The odoc PR is #349 on github, we just have to wait for it to be merged.</p><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../Utils/RngMap/index.html#module-type-S">Utils.RngMap.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../Utils/RngMap/module-type-S/index.html#type-obj">obj</a> := <a href="../../Ctype/index.html#type-t">Ctype.t</a></code></span></summary><dl><dt class="spec type" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span class="keyword">type</span> obj</code></dt><dd><p>The type of the contained object</p></dd></dl><dl><dt class="spec type" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span class="keyword">type</span> obj_off</code><code> = <a href="index.html#type-obj">obj</a> * int</code></dt><dd><p>The type of an object with an offset</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of the map from address ranges to <a href="index.html#type-obj"><code>obj</code></a></p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>An empty <code>RngMap</code></p></dd></dl><dl><dt class="spec value" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span class="keyword">val</span> is_in : <span>objaddr:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Test if an address is inside the object at address <code>objaddr</code></p></dd></dl><dl><dt class="spec value" id="val-at"><a href="#val-at" class="anchor"></a><code><span class="keyword">val</span> at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a></code></dt><dd><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span class="keyword">val</span> at_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj">obj</a> option</span></code></dt><dd><p>Get the object containing the address. <code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span class="keyword">val</span> at_off : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object</p><pre><code class="ml">at_off map addr = (obj, off) </code></pre><p>means:</p><pre>         |                      |           |         |
-       map 0                 obj start    point    obj end
-         |&lt;--------------addr--------------&gt;|
-                                |&lt;---off---&gt;|
-                                |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span class="keyword">val</span> at_off_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj_off">obj_off</a> option</span></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object. See <a href="index.html#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-update"><a href="#val-update" class="anchor"></a><code><span class="keyword">val</span> update : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></dd></dl><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span class="keyword">val</span> clear_at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear the object containing the address if any</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="index.html#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="index.html#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></dd></dl><dl><dt class="spec value" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span class="keyword">val</span> clear_crop : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span>crop:<span>(<span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></dd></dl><dl><dt class="spec value" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span class="keyword">val</span> clear_bounds : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="index.html#val-empty"><code>empty</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span class="keyword">val</span> addp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> list</span></code></dt><dd><p>Give the list of bindings</p></dd></dl><dl><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> <a href="../../Utils/index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dd><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt></dl></section><section><header><h2 id="environment"><a href="#environment" class="anchor"></a>Environment</h2></header><div class="spec module" id="module-Env"><a href="#module-Env" class="anchor"></a><code><span class="keyword">module</span> <a href="Env/index.html">Env</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-env"><a href="#type-env" class="anchor"></a><code><span class="keyword">type</span> env</code><code> = <a href="Env/index.html#type-t">Env.t</a></code></dt></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Fragment (read-dwarf.State.Fragment)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Fragment</nav><header class="odoc-preamble"><h1>Module <code><span>State.Fragment</span></code></h1><p>This module define a memory fragment to be used by C types</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#fragments">Fragments</a></li><li><a href="#environment">Environment</a></li></ul></nav></div><div class="odoc-content"><h2 id="fragments"><a href="#fragments" class="anchor"></a>Fragments</h2><div class="odoc-include"><div class="spec-doc"><p><code>obj</code> is just <a href="../../Ctype/index.html#type-t"><code>Ctype.t</code></a>, but a bug in odoc hides that information. <code>Fragment.obj</code> actually do not exists.</p><p>The odoc PR is #349 on github, we just have to wait for it to be merged.</p></div><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../Utils/RngMap/module-type-S/index.html">Utils.RngMap.S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../Utils/RngMap/module-type-S/index.html#type-obj">obj</a> := <a href="../../Ctype/index.html#type-t">Ctype.t</a></span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span><span class="keyword">type</span> obj_off</span><span> = <a href="../../Ctype/index.html#type-t">Ctype.t</a> * int</span></code></div><div class="spec-doc"><p>The type of an object with an offset</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of the map from address ranges to <code>obj</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>An empty <code>RngMap</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span><span class="keyword">val</span> is_in : <span><span class="label">objaddr</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test if an address is inside the object at address <code>objaddr</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at"><a href="#val-at" class="anchor"></a><code><span><span class="keyword">val</span> at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../../Ctype/index.html#type-t">Ctype.t</a></span></code></div><div class="spec-doc"><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address. <code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span><span class="keyword">val</span> at_off : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj_off">obj_off</a></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object</p><pre class="language-ocaml"><code>at_off map addr = (obj, off) </code></pre><p>means:</p><pre>   |                      |           |         |
+ map 0                 obj start    point    obj end
+   |&lt;--------------addr--------------&gt;|
+                          |&lt;---off---&gt;|
+                          |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_off_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object. See <a href="#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><span>(<span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ctype/index.html#type-t">Ctype.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ctype/index.html#type-t">Ctype.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ctype/index.html#type-t">Ctype.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span><span class="keyword">val</span> clear_at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear the object containing the address if any</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span><span class="keyword">val</span> clear_crop : 
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">crop</span>:<span>(<span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Ctype/index.html#type-t">Ctype.t</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span><span class="keyword">val</span> clear_bounds : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="#val-empty"><code>empty</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span><span class="keyword">val</span> addp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="../../Ctype/index.html#type-t">Ctype.t</a>)</span> list</span></span></code></div><div class="spec-doc"><p>Give the list of bindings</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="../../Ctype/index.html#type-t">Ctype.t</a>)</span> <a href="../../Utils/Seq/index.html#type-t">Utils.Seq.t</a></span></span></code></div><div class="spec-doc"><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><h2 id="environment"><a href="#environment" class="anchor"></a>Environment</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Env"><a href="#module-Env" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Env/index.html">Env</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-env"><a href="#type-env" class="anchor"></a><code><span><span class="keyword">type</span> env</span><span> = <a href="Env/index.html#type-t">Env.t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Reg/Map/index.html b/doc/html/read-dwarf/State/Reg/Map/index.html
index c060a6e6..ef8d36d9 100644
--- a/doc/html/read-dwarf/State/Reg/Map/index.html
+++ b/doc/html/read-dwarf/State/Reg/Map/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Map (read-dwarf.State.Reg.Map)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Reg</a> &#x00BB; Map</nav><h1>Module <code>Reg.Map</code></h1><p>This module provide a full map over register in the same way than <a href="../../../Utils/FullVec/index.html"><code>FullVec</code></a> provide a map of integers. It still need a generator to generate the value bound to not-yet-added registers.</p><p>Because the domain of registers is finite, some extra function are available like <a href="index.html#val-iter"><code>iter</code></a> and <a href="index.html#val-iteri"><code>iteri</code></a> that are not possible in <a href="../../../Utils/FullVec/index.html"><code>FullVec</code></a>.</p><p>If a register is added with <a href="../index.html#val-add"><code>add</code></a>, it is automatically and implicitly added to the <span class="xref-unresolved" title="unresolved reference to &quot;Utils.Map&quot;"><a href="../../../Utils/index.html"><code>Utils</code></a>.Map</span> and the generator must accept this new value. The generator will never be called on invalid register values (i.e. when the generator is called on a register, the former can get the latter's type and name with <a href="../index.html#val-reg_type"><code>reg_type</code></a> and <a href="../index.html#val-to_string"><code>to_string</code></a>)</p></header><dl><dt class="spec type" id="type-reg"><a href="#type-reg" class="anchor"></a><code><span class="keyword">type</span> reg</code><code> = <a href="../index.html#type-t">t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code></dt><dd><p>The type of the complete map</p></dd></dl><dl><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : <span>(<a href="index.html#type-reg">reg</a> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Initialize the map with a generator</p></dd></dl><dl><dt class="spec value" id="val-reinit"><a href="#val-reinit" class="anchor"></a><code><span class="keyword">val</span> reinit : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<a href="index.html#type-reg">reg</a> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear the map and restart with this generator</p></dd></dl><dl><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Make a copy of the map</p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-reg">reg</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the value of a register</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-reg">reg</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the value of a register</p></dd></dl><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Map the function all the registers (including future, not yet added ones)</p></dd></dl><dl><dt class="spec value" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span class="keyword">val</span> map_mut : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map the function on all the register by mutation (including future ones)</p></dd></dl><dl><dt class="spec value" id="val-map_mut_current"><a href="#val-map_mut_current" class="anchor"></a><code><span class="keyword">val</span> map_mut_current : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map the function on all current register. Future registers are unchanged</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterate over all the value of all currently present registers</p></dd></dl><dl><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(<a href="index.html#type-reg">reg</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-iter"><code>iter</code></a> but also with the register index</p></dd></dl><dl><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-reg">reg</a> * <span class="type-var">'a</span>)</span> list</span></code></dt><dd><p>Give all the registers bindings</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Contrary to <span class="xref-unresolved" title="unresolved reference to &quot;Utils.FullVector.pp&quot;"><span class="xref-unresolved" title="unresolved reference to &quot;Utils.FullVector&quot;"><a href="../../../Utils/index.html"><code>Utils</code></a>.FullVector</span>.pp</span>, this one will print the binding of all registers, and may call the generator to do that</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Map (read-dwarf.State.Reg.Map)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Reg</a> &#x00BB; Map</nav><header class="odoc-preamble"><h1>Module <code><span>Reg.Map</span></code></h1><p>This module provide a full map over register in the same way than <a href="../../../Utils/FullVec/index.html"><code>Utils.FullVec</code></a> provide a map of integers. It still need a generator to generate the value bound to not-yet-added registers.</p><p>Because the domain of registers is finite, some extra function are available like <a href="../index.html#val-iter"><code>iter</code></a> and <code>iteri</code> that are not possible in <a href="../../../Utils/FullVec/index.html"><code>Utils.FullVec</code></a>.</p><p>If a register is added with <a href="../index.html#val-add"><code>add</code></a>, it is automatically and implicitly added to the <code>Utils.Map</code> and the generator must accept this new value. The generator will never be called on invalid register values (i.e. when the generator is called on a register, the former can get the latter's type and name with <a href="../index.html#val-reg_type"><code>reg_type</code></a> and <a href="../index.html#val-to_string"><code>to_string</code></a>)</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-reg"><a href="#type-reg" class="anchor"></a><code><span><span class="keyword">type</span> reg</span><span> = <a href="../index.html#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span></code></div><div class="spec-doc"><p>The type of the complete map</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span><span>(<span><a href="#type-reg">reg</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Initialize the map with a generator</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reinit"><a href="#val-reinit" class="anchor"></a><code><span><span class="keyword">val</span> reinit : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><a href="#type-reg">reg</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear the map and restart with this generator</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Make a copy of the map</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-reg">reg</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the value of a register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-reg">reg</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the value of a register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Map the function all the registers (including future, not yet added ones)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span><a href="#type-reg">reg</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-map"><code>map</code></a> but with the index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span><span class="keyword">val</span> map_mut : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map the function on all the register by mutation (including future ones)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut_current"><a href="#val-map_mut_current" class="anchor"></a><code><span><span class="keyword">val</span> map_mut_current : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map the function on all current register. Future registers are unchanged</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterate over all the value of all currently present registers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span><a href="#type-reg">reg</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-iter"><code>iter</code></a> but also with the register index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-reg">reg</a> * <span class="type-var">'a</span>)</span> list</span></span></code></div><div class="spec-doc"><p>Give all the registers bindings</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Contrary to <code>Utils.FullVector.pp</code>, this one will print the binding of all registers, and may call the generator to do that</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Reg/Path/index.html b/doc/html/read-dwarf/State/Reg/Path/index.html
index 16d86748..b622f091 100644
--- a/doc/html/read-dwarf/State/Reg/Path/index.html
+++ b/doc/html/read-dwarf/State/Reg/Path/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Path (read-dwarf.State.Reg.Path)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Reg</a> &#x00BB; Path</nav><h1>Module <code>Reg.Path</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span>string list</span></code></dt></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Print the path as dotted list of identifier: <code>[&quot;A&quot;;&quot;B&quot;;&quot;C&quot;] -&gt; &quot;A.B.C&quot;</code></p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Parse the path as dotted list of identifier: <code>&quot;A.B.C&quot; -&gt; [&quot;A&quot;;&quot;B&quot;;&quot;C&quot;]</code></p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the path</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Path (read-dwarf.State.Reg.Path)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Reg</a> &#x00BB; Path</nav><header class="odoc-preamble"><h1>Module <code><span>Reg.Path</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span>string list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Print the path as dotted list of identifier: <code>[&quot;A&quot;;&quot;B&quot;;&quot;C&quot;] -&gt; &quot;A.B.C&quot;</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Parse the path as dotted list of identifier: <code>&quot;A.B.C&quot; -&gt; [&quot;A&quot;;&quot;B&quot;;&quot;C&quot;]</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the path</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Reg/index.html b/doc/html/read-dwarf/State/Reg/index.html
index b5afb465..b29db887 100644
--- a/doc/html/read-dwarf/State/Reg/index.html
+++ b/doc/html/read-dwarf/State/Reg/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Reg (read-dwarf.State.Reg)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Reg</nav><h1>Module <code>State.Reg</code></h1><p>This module handle the register abstraction.</p><p>A register is defined by a <a href="Path/index.html"><code>Path</code></a> and a type <a href="index.html#type-ty"><code>ty</code></a>. The path is a representation of dot separated list of identifiers.</p><p>Registers are not part of the <a href="../../Arch/index.html"><code>Arch</code></a> module because they are discovered dynamically. This module keeps a global index of all register of the current architecture (in a <a href="../../Utils/IdMap/index.html"><code>IdMap</code></a>). This map also fix the types of registers.</p><p>This allow to represent registers as integer everywhere.</p><p>The module also provides <a href="Map/index.html"><code>Map</code></a> and <code>PMap</code> a respectively full and partial maps over registers. They need special support (especially the full map) because new registers may be added at any time after the creation of the map.</p><p>TODO: Support sail vectors (A path will be of type (string + int) list)</p><nav class="toc"><ul><li><a href="#paths">Paths</a></li><li><a href="#registers">Registers</a></li><li><a href="#register-map">Register map</a></li></ul></nav></header><section><header><h2 id="paths"><a href="#paths" class="anchor"></a>Paths</h2><p>Representation of register path. The string reprensentation is with dots. A name may not contain dots, but this is not checked.</p></header><div class="spec module" id="module-Path"><a href="#module-Path" class="anchor"></a><code><span class="keyword">module</span> <a href="Path/index.html">Path</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div></section><section><header><h2 id="registers"><a href="#registers" class="anchor"></a>Registers</h2><p>Global register properties and accessors</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span class="keyword">private</span> int</code></dt><dd><p>The type representing a register. The module invariant is that this type always contains a value bound in the global index and so this is always a valid register id.</p></dd></dl><dl><dt class="spec type" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span class="keyword">type</span> ty</code><code> = <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></code></dt><dd><p>The type of a register. This is isomorphic to <span class="xref-unresolved" title="unresolved reference to &quot;Isla.ty&quot;"><a href="../../Isla/index.html"><code>Isla</code></a>.ty</span>. Use <span class="xref-unresolved" title="unresolved reference to &quot;IslaConv.ty&quot;"><code>IslaConv</code>.ty</span> to convert</p></dd></dl><dl><dt class="spec value" id="val-of_int"><a href="#val-of_int" class="anchor"></a><code><span class="keyword">val</span> of_int : int <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> option</span></code></dt><dd><p>Convert an integer into the corresponding register.</p></dd></dl><dl><dt class="spec value" id="val-mem_path"><a href="#val-mem_path" class="anchor"></a><code><span class="keyword">val</span> mem_path : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if register is declared with that path</p></dd></dl><dl><dt class="spec value" id="val-mem_string"><a href="#val-mem_string" class="anchor"></a><code><span class="keyword">val</span> mem_string : string <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if a register is declared with that name. Same as <code>Path.of_string |&gt; mem_path</code></p></dd></dl><dl><dt class="spec value" id="val-of_path"><a href="#val-of_path" class="anchor"></a><code><span class="keyword">val</span> of_path : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Give the register corresponding to that path</p></dd></dl><dl><dt class="spec value" id="val-to_path"><a href="#val-to_path" class="anchor"></a><code><span class="keyword">val</span> to_path : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Path/index.html#type-t">Path.t</a></code></dt><dd><p>Give the path of a register</p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Give the register corresponding to a register name</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Give the name of a register</p></dd></dl><dl><dt class="spec value" id="val-num"><a href="#val-num" class="anchor"></a><code><span class="keyword">val</span> num : unit <span>&#45;&gt;</span> int</code></dt><dd><p>Give the current number of registers</p></dd></dl><dl><dt class="spec value" id="val-reg_type"><a href="#val-reg_type" class="anchor"></a><code><span class="keyword">val</span> reg_type : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a></code></dt><dd><p>Give the type of a register</p></dd></dl><dl><dt class="spec value" id="val-path_type"><a href="#val-path_type" class="anchor"></a><code><span class="keyword">val</span> path_type : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a></code></dt><dd><p>Give the type of register path. Throw <code>Not_found</code>, it that path is not a declared register</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add a new register to the global <a href="../../index.html"><code>index</code></a>. Return it's representation</p></dd></dl><dl><dt class="spec value" id="val-ensure_add"><a href="#val-ensure_add" class="anchor"></a><code><span class="keyword">val</span> ensure_add : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Ensure that a register with that path exists with that type, by adding it or checking it already exists with that type. Return the corresponding register</p></dd></dl><dl><dt class="spec value" id="val-adds"><a href="#val-adds" class="anchor"></a><code><span class="keyword">val</span> adds : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-add"><code>add</code></a> but returns unit</p></dd></dl><dl><dt class="spec value" id="val-ensure_adds"><a href="#val-ensure_adds" class="anchor"></a><code><span class="keyword">val</span> ensure_adds : <a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Ensure that a register with that path exists with that type, by adding it or checking it already exists with that type.</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="Path/index.html#type-t">Path.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-ty">ty</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Run a function over all registers</p></dd></dl><dl><dt class="spec value" id="val-seq_all"><a href="#val-seq_all" class="anchor"></a><code><span class="keyword">val</span> seq_all : unit <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> <a href="../../Utils/index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dd><p>Returns a sequence of all registers</p></dd></dl><dl><dt class="spec value" id="val-(=)"><a href="#val-(=)" class="anchor"></a><code><span class="keyword">val</span> (=) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality predicate</p></dd></dl><dl><dt class="spec value" id="val-(&lt;&gt;)"><a href="#val-(&lt;&gt;)" class="anchor"></a><code><span class="keyword">val</span> (&lt;&gt;) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Inequality predicate</p></dd></dl><dl><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Compare according to an implementation-defined total order.</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints a register (Just use <a href="index.html#val-to_string"><code>to_string</code></a>)</p></dd></dl><dl><dt class="spec value" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span class="keyword">val</span> pp_ty : <a href="index.html#type-ty">ty</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints a register type</p></dd></dl><dl><dt class="spec value" id="val-pp_index"><a href="#val-pp_index" class="anchor"></a><code><span class="keyword">val</span> pp_index : unit <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Prints the register index (mainly for debugging I suppose)</p></dd></dl></section><section><header><h2 id="register-map"><a href="#register-map" class="anchor"></a>Register map</h2><p>To achieve a partial map on register, one may just used a plain <code>Hashtbl</code>. However as register is a finite type one may want to have a map where all the register are bound and thus access to a bound value cannot fail. This is complicated by the fact that new registers can be added after the creation of the map. To handle all those subtleties, there is the <span class="xref-unresolved" title="unresolved reference to &quot;Utils.Map&quot;"><a href="../../Utils/index.html"><code>Utils</code></a>.Map</span> module.</p></header><dl><dt class="spec module" id="module-Map"><a href="#module-Map" class="anchor"></a><code><span class="keyword">module</span> <a href="Map/index.html">Map</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide a full map over register in the same way than <a href="../../Utils/FullVec/index.html"><code>FullVec</code></a> provide a map of integers. It still need a generator to generate the value bound to not-yet-added registers.</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Reg (read-dwarf.State.Reg)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Reg</nav><header class="odoc-preamble"><h1>Module <code><span>State.Reg</span></code></h1><p>This module handle the register abstraction.</p><p>A register is defined by a <a href="Path/index.html"><code>Path</code></a> and a type <a href="#type-ty"><code>ty</code></a>. The path is a representation of dot separated list of identifiers.</p><p>Registers are not part of the <a href="../../Arch/index.html"><code>Arch</code></a> module because they are discovered dynamically. This module keeps a global index of all register of the current architecture (in a <a href="../../Utils/IdMap/index.html"><code>Utils.IdMap</code></a>). This map also fix the types of registers.</p><p>This allow to represent registers as integer everywhere.</p><p>The module also provides <a href="Map/index.html"><code>Map</code></a> and <code>PMap</code> a respectively full and partial maps over registers. They need special support (especially the full map) because new registers may be added at any time after the creation of the map.</p><p>TODO: Support sail vectors (A path will be of type (string + int) list)</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#paths">Paths</a></li><li><a href="#registers">Registers</a></li><li><a href="#register-map">Register map</a></li></ul></nav></div><div class="odoc-content"><h2 id="paths"><a href="#paths" class="anchor"></a>Paths</h2><p>Representation of register path. The string reprensentation is with dots. A name may not contain dots, but this is not checked.</p><div class="odoc-spec"><div class="spec module anchored" id="module-Path"><a href="#module-Path" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Path/index.html">Path</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><h2 id="registers"><a href="#registers" class="anchor"></a>Registers</h2><p>Global register properties and accessors</p><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span class="keyword">private</span> int</span></code></div><div class="spec-doc"><p>The type representing a register. The module invariant is that this type always contains a value bound in the global index and so this is always a valid register id.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ty"><a href="#type-ty" class="anchor"></a><code><span><span class="keyword">type</span> ty</span><span> = <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span></span></code></div><div class="spec-doc"><p>The type of a register. This is isomorphic to <a href="../../Isla/index.html#type-ty"><code>Isla.ty</code></a>. Use <code>IslaConv.ty</code> to convert</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_int"><a href="#val-of_int" class="anchor"></a><code><span><span class="keyword">val</span> of_int : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> option</span></span></code></div><div class="spec-doc"><p>Convert an integer into the corresponding register.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_path"><a href="#val-mem_path" class="anchor"></a><code><span><span class="keyword">val</span> mem_path : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if register is declared with that path</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_string"><a href="#val-mem_string" class="anchor"></a><code><span><span class="keyword">val</span> mem_string : <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if a register is declared with that name. Same as <code>Path.of_string |&gt; mem_path</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_path"><a href="#val-of_path" class="anchor"></a><code><span><span class="keyword">val</span> of_path : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Give the register corresponding to that path</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_path"><a href="#val-to_path" class="anchor"></a><code><span><span class="keyword">val</span> to_path : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="Path/index.html#type-t">Path.t</a></span></code></div><div class="spec-doc"><p>Give the path of a register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Give the register corresponding to a register name</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Give the name of a register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-num"><a href="#val-num" class="anchor"></a><code><span><span class="keyword">val</span> num : <span>unit <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Give the current number of registers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reg_type"><a href="#val-reg_type" class="anchor"></a><code><span><span class="keyword">val</span> reg_type : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-ty">ty</a></span></code></div><div class="spec-doc"><p>Give the type of a register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-path_type"><a href="#val-path_type" class="anchor"></a><code><span><span class="keyword">val</span> path_type : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-ty">ty</a></span></code></div><div class="spec-doc"><p>Give the type of register path. Throw <code>Not_found</code>, it that path is not a declared register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-ty">ty</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add a new register to the global <a href="../../index.html"><code>index</code></a>. Return it's representation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_add"><a href="#val-ensure_add" class="anchor"></a><code><span><span class="keyword">val</span> ensure_add : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-ty">ty</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Ensure that a register with that path exists with that type, by adding it or checking it already exists with that type. Return the corresponding register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-adds"><a href="#val-adds" class="anchor"></a><code><span><span class="keyword">val</span> adds : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-ty">ty</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-add"><code>add</code></a> but returns unit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_adds"><a href="#val-ensure_adds" class="anchor"></a><code><span><span class="keyword">val</span> ensure_adds : <span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-ty">ty</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Ensure that a register with that path exists with that type, by adding it or checking it already exists with that type.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="Path/index.html#type-t">Path.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-ty">ty</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Run a function over all registers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-seq_all"><a href="#val-seq_all" class="anchor"></a><code><span><span class="keyword">val</span> seq_all : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <a href="../../Utils/Seq/index.html#type-t">Utils.Seq.t</a></span></span></code></div><div class="spec-doc"><p>Returns a sequence of all registers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=)"><a href="#val-(=)" class="anchor"></a><code><span><span class="keyword">val</span> (=) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Equality predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(&lt;&gt;)"><a href="#val-(&lt;&gt;)" class="anchor"></a><code><span><span class="keyword">val</span> (&lt;&gt;) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Inequality predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Compare according to an implementation-defined total order.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints a register (Just use <a href="#val-to_string"><code>to_string</code></a>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_ty"><a href="#val-pp_ty" class="anchor"></a><code><span><span class="keyword">val</span> pp_ty : <span><a href="#type-ty">ty</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints a register type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_index"><a href="#val-pp_index" class="anchor"></a><code><span><span class="keyword">val</span> pp_index : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Prints the register index (mainly for debugging I suppose)</p></div></div><h2 id="register-map"><a href="#register-map" class="anchor"></a>Register map</h2><p>To achieve a partial map on register, one may just used a plain <code>Hashtbl</code>. However as register is a finite type one may want to have a map where all the register are bound and thus access to a bound value cannot fail. This is complicated by the fact that new registers can be added after the creation of the map. To handle all those subtleties, there is the <code>Utils.Map</code> module.</p><div class="odoc-spec"><div class="spec module anchored" id="module-Map"><a href="#module-Map" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Map/index.html">Map</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a full map over register in the same way than <a href="../../Utils/FullVec/index.html"><code>Utils.FullVec</code></a> provide a map of integers. It still need a generator to generate the value bound to not-yet-added registers.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Simplify/ContextFull/index.html b/doc/html/read-dwarf/State/Simplify/ContextFull/index.html
index 21566bbf..6a4b8d4c 100644
--- a/doc/html/read-dwarf/State/Simplify/ContextFull/index.html
+++ b/doc/html/read-dwarf/State/Simplify/ContextFull/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ContextFull (read-dwarf.State.Simplify.ContextFull)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Simplify</a> &#x00BB; ContextFull</nav><h1>Module <code>Simplify.ContextFull</code></h1><p>Do a context aware simplify, for now, it just does a context free simplify and then remove assertion that proven true or false by Z3</p></header><dl><dt class="spec value" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span class="keyword">val</span> counter : <a href="../../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></code></dt><dt class="spec value" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span class="keyword">val</span> openc : unit <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-num"><a href="#val-num" class="anchor"></a><code><span class="keyword">val</span> num : unit <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span class="keyword">val</span> closec : unit <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ContextFull (read-dwarf.State.Simplify.ContextFull)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Simplify</a> &#x00BB; ContextFull</nav><header class="odoc-preamble"><h1>Module <code><span>Simplify.ContextFull</span></code></h1><p>Do a context aware simplify, for now, it just does a context free simplify and then remove assertion that proven true or false by Z3</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span><span class="keyword">val</span> counter : <a href="../../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span><span class="keyword">val</span> openc : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-num"><a href="#val-num" class="anchor"></a><code><span><span class="keyword">val</span> num : <span>unit <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span><span class="keyword">val</span> closec : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Simplify/Z3St/Htbl/index.html b/doc/html/read-dwarf/State/Simplify/Z3St/Htbl/index.html
index f5f52eda..b7972655 100644
--- a/doc/html/read-dwarf/State/Simplify/Z3St/Htbl/index.html
+++ b/doc/html/read-dwarf/State/Simplify/Z3St/Htbl/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Htbl (read-dwarf.State.Simplify.Z3St.Htbl)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">State</a> &#x00BB; <a href="../../index.html">Simplify</a> &#x00BB; <a href="../index.html">Z3St</a> &#x00BB; Htbl</nav><h1>Module <code>Z3St.Htbl</code></h1></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../index.html#type-var">var</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> <a href="../../../../Z3/Make/index.html#module-Htbl">Z3.Make(State__.Base.Var).Htbl</a>.t</span></code></dt></dl><dl><dt class="spec value" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span class="keyword">val</span> reset : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span class="keyword">val</span> find_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span class="keyword">val</span> find_all : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span class="keyword">val</span> replace : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span class="keyword">val</span> filter_map_inplace : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span class="keyword">val</span> stats : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> Stdlib.Hashtbl.statistics</code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span class="keyword">val</span> to_seq_keys : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-key">key</a> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span class="keyword">val</span> to_seq_values : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span class="keyword">val</span> add_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span class="keyword">val</span> replace_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Htbl (read-dwarf.State.Simplify.Z3St.Htbl)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">State</a> &#x00BB; <a href="../../index.html">Simplify</a> &#x00BB; <a href="../index.html">Z3St</a> &#x00BB; Htbl</nav><header class="odoc-preamble"><h1>Module <code><span>Z3St.Htbl</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../index.html#type-var">var</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Z3</span>.Make(<span class="xref-unresolved">State__</span>.Base.Var).Htbl.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span><span class="keyword">val</span> replace : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span><span class="keyword">val</span> filter_map_inplace : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span><span class="keyword">val</span> stats : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib__Hashtbl</span>.statistics</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_keys : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_values : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span><span class="keyword">val</span> add_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span><span class="keyword">val</span> replace_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Simplify/Z3St/index.html b/doc/html/read-dwarf/State/Simplify/Z3St/index.html
index 4ca8fdd1..71df6e7e 100644
--- a/doc/html/read-dwarf/State/Simplify/Z3St/index.html
+++ b/doc/html/read-dwarf/State/Simplify/Z3St/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3St (read-dwarf.State.Simplify.Z3St)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Simplify</a> &#x00BB; Z3St</nav><h1>Module <code>Simplify.Z3St</code></h1></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../../Base/Var/index.html#type-t">Base.Var.t</a></code></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><div class="spec module" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span class="keyword">module</span> <a href="Htbl/index.html">Htbl</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span class="keyword">val</span> declare_var_always : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span class="keyword">val</span> declare_var : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span class="keyword">val</span> declare_vars : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span class="keyword">val</span> simplify_decl : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span class="keyword">val</span> send_assert : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span class="keyword">val</span> send_assert_decl : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-check"><a href="#val-check" class="anchor"></a><code><span class="keyword">val</span> check : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span class="keyword">val</span> check_sat : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span class="keyword">val</span> check_both : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span class="keyword">val</span> simplify_full : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span class="keyword">val</span> check_full : <span>?&#8288;hyps:<span><a href="index.html#type-exp">exp</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span class="keyword">val</span> check_sat_full : <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> <span>bool option</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3St (read-dwarf.State.Simplify.Z3St)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">Simplify</a> &#x00BB; Z3St</nav><header class="odoc-preamble"><h1>Module <code><span>Simplify.Z3St</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../../Base/Var/index.html#type-t">Base.Var.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Htbl/index.html">Htbl</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span><span class="keyword">val</span> declare_var_always : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span><span class="keyword">val</span> declare_var : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span><span class="keyword">val</span> declare_vars : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span><span class="keyword">val</span> send_assert : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span><span class="keyword">val</span> send_assert_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check"><a href="#val-check" class="anchor"></a><code><span><span class="keyword">val</span> check : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span><span class="keyword">val</span> check_sat : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span><span class="keyword">val</span> check_both : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms"><a href="#val-simplify_subterms" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_decl"><a href="#val-simplify_subterms_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_full : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span><span class="keyword">val</span> check_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span><span class="keyword">val</span> check_sat_full : <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_full"><a href="#val-simplify_subterms_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Simplify/index.html b/doc/html/read-dwarf/State/Simplify/index.html
index d1183674..6bc18d77 100644
--- a/doc/html/read-dwarf/State/Simplify/index.html
+++ b/doc/html/read-dwarf/State/Simplify/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Simplify (read-dwarf.State.Simplify)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Simplify</nav><h1>Module <code>State.Simplify</code></h1><p>This module provide utility to simplify states</p></header><div class="spec module" id="module-Z3St"><a href="#module-Z3St" class="anchor"></a><code><span class="keyword">module</span> <a href="Z3St/index.html">Z3St</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-ctxfree"><a href="#val-ctxfree" class="anchor"></a><code><span class="keyword">val</span> ctxfree : <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Context free simplify, just expression by expression. Do it mutably</p></dd></dl><dl><dt class="spec module" id="module-ContextFull"><a href="#module-ContextFull" class="anchor"></a><code><span class="keyword">module</span> <a href="ContextFull/index.html">ContextFull</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Do a context aware simplify, for now, it just does a context free simplify and then remove assertion that proven true or false by Z3</p></dd></dl><dl><dt class="spec value" id="val-ctxfull"><a href="#val-ctxfull" class="anchor"></a><code><span class="keyword">val</span> ctxfull : <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Do a context aware simplify, for now, it just does a context free simplify and then remove assertion that proven true or false by Z3.</p><p>If a state has a false assertion anywhere then all assertions will collapse in a single false.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Simplify (read-dwarf.State.Simplify)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Simplify</nav><header class="odoc-preamble"><h1>Module <code><span>State.Simplify</span></code></h1><p>This module provide utility to simplify states</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Z3St"><a href="#module-Z3St" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Z3St/index.html">Z3St</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ctxfree"><a href="#val-ctxfree" class="anchor"></a><code><span><span class="keyword">val</span> ctxfree : <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Context free simplify, just expression by expression. Do it mutably</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ContextFull"><a href="#module-ContextFull" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ContextFull/index.html">ContextFull</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Do a context aware simplify, for now, it just does a context free simplify and then remove assertion that proven true or false by Z3</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ctxfull"><a href="#val-ctxfull" class="anchor"></a><code><span><span class="keyword">val</span> ctxfull : <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Do a context aware simplify, for now, it just does a context free simplify and then remove assertion that proven true or false by Z3.</p><p>If a state has a false assertion anywhere then all assertions will collapse in a single false.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/SymbolicBytes/Make/argument-1-Var/index.html b/doc/html/read-dwarf/State/SymbolicBytes/Make/argument-1-Var/index.html
index 94ab0a60..04363ebb 100644
--- a/doc/html/read-dwarf/State/SymbolicBytes/Make/argument-1-Var/index.html
+++ b/doc/html/read-dwarf/State/SymbolicBytes/Make/argument-1-Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Var (read-dwarf.State.SymbolicBytes.Make.1-Var)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">State</a> &#x00BB; <a href="../../index.html">SymbolicBytes</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 1-Var</nav><h1>Parameter <code>Make.1-Var</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of variables</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality predicate that will be passed to expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></dd></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../../Exp/index.html#type-ty">Exp.ty</a></code></dt><dd><p>Get the type of the variable</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.State.SymbolicBytes.Make.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">State</a> &#x00BB; <a href="../../index.html">SymbolicBytes</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Var</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Equality predicate that will be passed to expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../../Exp/index.html#type-ty">Exp.ty</a></span></code></div><div class="spec-doc"><p>Get the type of the variable</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/SymbolicBytes/Make/index.html b/doc/html/read-dwarf/State/SymbolicBytes/Make/index.html
index fa1465bd..851e664c 100644
--- a/doc/html/read-dwarf/State/SymbolicBytes/Make/index.html
+++ b/doc/html/read-dwarf/State/SymbolicBytes/Make/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.State.SymbolicBytes.Make)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">SymbolicBytes</a> &#x00BB; Make</nav><h1>Module <code>SymbolicBytes.Make</code></h1></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Var/index.html">Var</a> : <a href="../../../Exp/index.html#module-type-Var">Exp.Var</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="argument-1-Var/index.html#type-t">Var.t</a></code></dt><dd><p>The type of variables used</p></dd></dl><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of symbolic bytes.</p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>The empty symbolic byte sequence with no bytes defined</p></dd></dl><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> option</span></code></dt><dd><p>Extract an expression in <code>[pos:pos+len)</code>. If any bytes in the range is undefined, Then <code>None</code> is returned, otherwise a expression is returned</p></dd></dl><dl><dt class="spec value" id="val-blit_exp"><a href="#val-blit_exp" class="anchor"></a><code><span class="keyword">val</span> blit_exp : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Write the expresion on the interval <code>[pos:pos +len)</code> of the bytes. The expression must be a bitvector of size exactly <code>8 * len</code>.</p><p>TODO check it when values are type annotated</p></dd></dl><dl><dt class="spec value" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span class="keyword">val</span> clear_bounds : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear a range of the symbolic bytes, making all those bytes undefined again. If a bound is missing, it means up to infinity in that direction</p></dd></dl><dl><dt class="spec value" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span class="keyword">val</span> map_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the contained expressions</p></dd></dl><dl><dt class="spec value" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span class="keyword">val</span> iter_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the contained expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints the symbolic bytes</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.State.SymbolicBytes.Make)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">SymbolicBytes</a> &#x00BB; Make</nav><header class="odoc-preamble"><h1>Module <code><span>SymbolicBytes.Make</span></code></h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Var"><a href="#argument-1-Var" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Var/index.html">Var</a></span><span> : <a href="../../../Exp/module-type-Var/index.html">Exp.Var</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="argument-1-Var/index.html#type-t">Var.t</a></span></code></div><div class="spec-doc"><p>The type of variables used</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of symbolic bytes.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The empty symbolic byte sequence with no bytes defined</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> option</span></span></code></div><div class="spec-doc"><p>Extract an expression in <code>[pos:pos+len)</code>. If any bytes in the range is undefined, Then <code>None</code> is returned, otherwise a expression is returned</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit_exp"><a href="#val-blit_exp" class="anchor"></a><code><span><span class="keyword">val</span> blit_exp : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Write the expresion on the interval <code>[pos:pos +len)</code> of the bytes. The expression must be a bitvector of size exactly <code>8 * len</code>.</p><p>TODO check it when values are type annotated</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span><span class="keyword">val</span> clear_bounds : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear a range of the symbolic bytes, making all those bytes undefined again. If a bound is missing, it means up to infinity in that direction</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span><span class="keyword">val</span> map_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the contained expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> iter_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the contained expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints the symbolic bytes</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/SymbolicBytes/index.html b/doc/html/read-dwarf/State/SymbolicBytes/index.html
index 21e8f692..b3e2493a 100644
--- a/doc/html/read-dwarf/State/SymbolicBytes/index.html
+++ b/doc/html/read-dwarf/State/SymbolicBytes/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymbolicBytes (read-dwarf.State.SymbolicBytes)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; SymbolicBytes</nav><h1>Module <code>State.SymbolicBytes</code></h1><p>This module provide high-level support for a symbolic array of bytes.</p><p>The main differences between this and a big <code>concat</code> expression is that:</p><ul><li>It allows some bytes to be undefined</li><li>It allows fast (logarithmic or better) access to any byte or group of bytes.</li><li>It provides dedicated functions for efficiently extracting an expression from a range of bytes (reading) or blitting (writing) an expression to a range of bytes.</li><li>The indexing can start at any point (negative value can be mapped) without any costs</li></ul><p>This data structure deliberately do not have any infrastructure to read or write bytes at symbolic positions. See <code>SymbolicFragment</code> for that.</p><p>This data structure do not have a concept of beginning or an end (But it has the concept of first defined byte and last defined byte). In particular addresses can be negative.</p><p>It is functorized of the type of variables (<a href="../Var/index.html"><code>Var</code></a>) to get variable equality and pretty-printing</p><p>Currently this has a pure interface.</p></header><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span class="keyword">module</span> <a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-Var/index.html">Var</a> : <a href="../../Exp/index.html#module-type-Var">Exp.Var</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-S">S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="Make/index.html#type-var">var</a> = <a href="Make/argument-1-Var/index.html#type-t">Var.t</a></code></div></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymbolicBytes (read-dwarf.State.SymbolicBytes)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; SymbolicBytes</nav><header class="odoc-preamble"><h1>Module <code><span>State.SymbolicBytes</span></code></h1><p>This module provide high-level support for a symbolic array of bytes.</p><p>The main differences between this and a big <code>concat</code> expression is that:</p><ul><li>It allows some bytes to be undefined</li><li>It allows fast (logarithmic or better) access to any byte or group of bytes.</li><li>It provides dedicated functions for efficiently extracting an expression from a range of bytes (reading) or blitting (writing) an expression to a range of bytes.</li><li>The indexing can start at any point (negative value can be mapped) without any costs</li></ul><p>This data structure deliberately do not have any infrastructure to read or write bytes at symbolic positions. See <code>SymbolicFragment</code> for that.</p><p>This data structure do not have a concept of beginning or an end (But it has the concept of first defined byte and last defined byte). In particular addresses can be negative.</p><p>It is functorized of the type of variables (<a href="../Base/Var/index.html"><code>Var</code></a>) to get variable equality and pretty-printing</p><p>Currently this has a pure interface.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Make/index.html">Make</a></span><span> (<a href="Make/argument-1-Var/index.html">Var</a> : <a href="../../Exp/module-type-Var/index.html">Exp.Var</a>) : <a href="module-type-S/index.html">S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-var">var</a> = <a href="Make/argument-1-Var/index.html#type-t">Var.t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/SymbolicBytes/module-type-S/index.html b/doc/html/read-dwarf/State/SymbolicBytes/module-type-S/index.html
index 53b8ad9e..a49dbda4 100644
--- a/doc/html/read-dwarf/State/SymbolicBytes/module-type-S/index.html
+++ b/doc/html/read-dwarf/State/SymbolicBytes/module-type-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.State.SymbolicBytes.S)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">SymbolicBytes</a> &#x00BB; S</nav><h1>Module type <code>SymbolicBytes.S</code></h1></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code></dt><dd><p>The type of variables used</p></dd></dl><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of symbolic bytes.</p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>The empty symbolic byte sequence with no bytes defined</p></dd></dl><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> option</span></code></dt><dd><p>Extract an expression in <code>[pos:pos+len)</code>. If any bytes in the range is undefined, Then <code>None</code> is returned, otherwise a expression is returned</p></dd></dl><dl><dt class="spec value" id="val-blit_exp"><a href="#val-blit_exp" class="anchor"></a><code><span class="keyword">val</span> blit_exp : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Write the expresion on the interval <code>[pos:pos +len)</code> of the bytes. The expression must be a bitvector of size exactly <code>8 * len</code>.</p><p>TODO check it when values are type annotated</p></dd></dl><dl><dt class="spec value" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span class="keyword">val</span> clear_bounds : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear a range of the symbolic bytes, making all those bytes undefined again. If a bound is missing, it means up to infinity in that direction</p></dd></dl><dl><dt class="spec value" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span class="keyword">val</span> map_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the contained expressions</p></dd></dl><dl><dt class="spec value" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span class="keyword">val</span> iter_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the contained expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints the symbolic bytes</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.State.SymbolicBytes.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">State</a> &#x00BB; <a href="../index.html">SymbolicBytes</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Module type <code><span>SymbolicBytes.S</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span></code></div><div class="spec-doc"><p>The type of variables used</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of symbolic bytes.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The empty symbolic byte sequence with no bytes defined</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> option</span></span></code></div><div class="spec-doc"><p>Extract an expression in <code>[pos:pos+len)</code>. If any bytes in the range is undefined, Then <code>None</code> is returned, otherwise a expression is returned</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit_exp"><a href="#val-blit_exp" class="anchor"></a><code><span><span class="keyword">val</span> blit_exp : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Write the expresion on the interval <code>[pos:pos +len)</code> of the bytes. The expression must be a bitvector of size exactly <code>8 * len</code>.</p><p>TODO check it when values are type annotated</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span><span class="keyword">val</span> clear_bounds : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear a range of the symbolic bytes, making all those bytes undefined again. If a bound is missing, it means up to infinity in that direction</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_exp"><a href="#val-map_exp" class="anchor"></a><code><span><span class="keyword">val</span> map_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the contained expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> iter_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the contained expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints the symbolic bytes</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/Tree/index.html b/doc/html/read-dwarf/State/Tree/index.html
index a34d86a7..2f935422 100644
--- a/doc/html/read-dwarf/State/Tree/index.html
+++ b/doc/html/read-dwarf/State/Tree/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Tree (read-dwarf.State.Tree)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Tree</nav><h1>Module <code>State.Tree</code></h1><p>This module provides a tree of state to represent an unmerged execution</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = </code><code>{</code><table class="record"><tr id="type-t.state" class="anchored"><td class="def field"><a href="#type-t.state" class="anchor"></a><code>state : <a href="../Base/index.html#type-t">Base.t</a>;</code></td></tr><tr id="type-t.data" class="anchored"><td class="def field"><a href="#type-t.data" class="anchor"></a><code>data : <span class="type-var">'a</span>;</code></td></tr><tr id="type-t.rest" class="anchored"><td class="def field"><a href="#type-t.rest" class="anchor"></a><code>rest : <span><span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> list</span>;</code></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-bars"><a href="#val-bars" class="anchor"></a><code><span class="keyword">val</span> bars : string</code></dt><dt class="spec value" id="val-bars_length"><a href="#val-bars_length" class="anchor"></a><code><span class="keyword">val</span> bars_length : int</code></dt><dt class="spec value" id="val-startbar"><a href="#val-startbar" class="anchor"></a><code><span class="keyword">val</span> startbar : int <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-prefix_iter"><a href="#val-prefix_iter" class="anchor"></a><code><span class="keyword">val</span> prefix_iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-postfix_iter"><a href="#val-postfix_iter" class="anchor"></a><code><span class="keyword">val</span> postfix_iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Default iter when you don't care about order</p></dd></dl><dl><dt class="spec value" id="val-map_to_list"><a href="#val-map_to_list" class="anchor"></a><code><span class="keyword">val</span> map_to_list : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span></code></dt><dd><p>This is prefix, do a List.rev to get a postfix version</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_all"><a href="#val-pp_all" class="anchor"></a><code><span class="keyword">val</span> pp_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Tree (read-dwarf.State.Tree)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">State</a> &#x00BB; Tree</nav><header class="odoc-preamble"><h1>Module <code><span>State.Tree</span></code></h1><p>This module provides a tree of state to represent an unmerged execution</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span><span> = </span><span>{</span></code><ol><li id="type-t.state" class="def record field anchored"><a href="#type-t.state" class="anchor"></a><code><span>state : <a href="../Base/index.html#type-t">Base.t</a>;</span></code></li><li id="type-t.data" class="def record field anchored"><a href="#type-t.data" class="anchor"></a><code><span>data : <span class="type-var">'a</span>;</span></code></li><li id="type-t.rest" class="def record field anchored"><a href="#type-t.rest" class="anchor"></a><code><span>rest : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> list</span>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bars"><a href="#val-bars" class="anchor"></a><code><span><span class="keyword">val</span> bars : string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bars_length"><a href="#val-bars_length" class="anchor"></a><code><span><span class="keyword">val</span> bars_length : int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-startbar"><a href="#val-startbar" class="anchor"></a><code><span><span class="keyword">val</span> startbar : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prefix_iter"><a href="#val-prefix_iter" class="anchor"></a><code><span><span class="keyword">val</span> prefix_iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-postfix_iter"><a href="#val-postfix_iter" class="anchor"></a><code><span><span class="keyword">val</span> postfix_iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Default iter when you don't care about order</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_to_list"><a href="#val-map_to_list" class="anchor"></a><code><span><span class="keyword">val</span> map_to_list : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p>This is prefix, do a List.rev to get a postfix version</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_all"><a href="#val-pp_all" class="anchor"></a><code><span><span class="keyword">val</span> pp_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/State/index.html b/doc/html/read-dwarf/State/index.html
index 1cbee381..e2a71c84 100644
--- a/doc/html/read-dwarf/State/index.html
+++ b/doc/html/read-dwarf/State/index.html
@@ -1,2 +1,14 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>State (read-dwarf.State)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; State</nav><h1>Module <code>State</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="index.html#module-Base">Base</a></code></span></summary><aside><p>This module introduce a type to represent the state of the machine.</p><p>The symbolic state in this module do not mathematically represent a single state but a set of concrete state with all the symbolic variable over the whole range of their types. State also contain assertions, and so only represent the subset of concrete states, that satisfy all assertions.</p><p>Currently the state type only represent the register (including system register) and sequential memory part of an actual machine state. Any other architectural state is not represented.</p><p>Additionally, state contain C type information for the <a href="../Ctype/index.html"><code>Ctype</code></a> inference system. Those fields are not semantically part of the state and do not influence in any way which concrete states are represented by the symbolic state. Expect for provenance information: Pointers can be tagged with provenance information which mean that they are part of a specific restricted block of memory or the main block. See <a href="Mem/index.html"><code>Mem</code></a> for more information. Thus all the implicit non-aliasing assertion implied by those provenance field are to be considered as part of the group of assertion restricting the set of concrete state represented by a symbolic state.</p><p>The presence of C types is optional, which means that this state type can be used in a completely untyped context.</p><p>Concrete detail about how symbolic state are represented in Ocaml is in the documentation of <a href="index.html#type-t"><code>t</code></a>.</p></aside><section><header><h2 id="state-id"><a href="#state-id" class="anchor"></a>State id</h2></header><dl><dt class="spec module" id="module-Id"><a href="#module-Id" class="anchor"></a><code><span class="keyword">module</span> Id = <a href="Base/index.html#module-Id">Base.Id</a></code></dt><dd><p>The type of a state ID. for now it's an integer, but it may change later In particular whether a state belong to O0 or O2 may be part of the <code>id</code> at some point.</p></dd></dl><dl><dt class="spec type" id="type-id"><a href="#type-id" class="anchor"></a><code><span class="keyword">type</span> id</code><code> = <a href="Id/index.html#type-t">Id.t</a></code></dt></dl></section><section><header><h2 id="state-variable-management"><a href="#state-variable-management" class="anchor"></a>State variable management</h2></header><dl><dt class="spec module" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span class="keyword">module</span> Var = <a href="Base/index.html#module-Var">Base.Var</a></code></dt><dd><p>This module provide state variables. Those are all symbolic variables that may appear in a state. If the same (in the <a href="Var/index.html#val-equal"><code>Var.equal</code></a> sense) variable appear in two state, that mean that when considered together, there is an implicit relation between them.</p></dd></dl><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="Var/index.html#type-t">Var.t</a></code></dt><dd><p>The type of variables</p></dd></dl></section><section><header><h2 id="state-expression-and-typed-value-management"><a href="#state-expression-and-typed-value-management" class="anchor"></a>State expression and typed-value management</h2></header><dl><dt class="spec module" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span class="keyword">module</span> Exp = <a href="Base/index.html#module-Exp">Base.Exp</a></code></dt><dd><p>Module for state expressions</p></dd></dl><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <a href="Exp/index.html#type-t">Exp.t</a></code></dt></dl><dl><dt class="spec module" id="module-Tval"><a href="#module-Tval" class="anchor"></a><code><span class="keyword">module</span> Tval = <a href="Base/index.html#module-Tval">Base.Tval</a></code></dt><dd><p>Module for optionally typed state expressions. Those are symbolic values which may or may not have a C type.</p></dd></dl><dl><dt class="spec type" id="type-tval"><a href="#type-tval" class="anchor"></a><code><span class="keyword">type</span> tval</code><code> = <a href="Tval/index.html#type-t">Tval.t</a></code></dt></dl></section><section><header><h2 id="state-memory-management"><a href="#state-memory-management" class="anchor"></a>State memory management</h2></header><dl><dt class="spec module" id="module-Mem"><a href="#module-Mem" class="anchor"></a><code><span class="keyword">module</span> Mem = <a href="Base/index.html#module-Mem">Base.Mem</a></code></dt><dd><p>This module manages the memory part of the state.</p></dd></dl></section><section><header><h2 id="state-type"><a href="#state-type" class="anchor"></a>State type</h2></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span class="keyword">private</span> </code><code>{</code><table class="record"><tr id="type-t.id" class="anchored"><td class="def field"><a href="#type-t.id" class="anchor"></a><code>id : <a href="index.html#type-id">id</a>;</code></td></tr><tr id="type-t.base_state" class="anchored"><td class="def field"><a href="#type-t.base_state" class="anchor"></a><code>base_state : <span><a href="index.html#type-t">t</a> option</span>;</code></td><td class="doc"><p>The immediate dominator state in the control flow graph</p></td></tr><tr id="type-t.locked" class="anchored"><td class="def field"><a href="#type-t.locked" class="anchor"></a><code><span class="keyword">mutable</span> locked : bool;</code></td><td class="doc"><p>Tells if the state is locked</p></td></tr><tr id="type-t.regs" class="anchored"><td class="def field"><a href="#type-t.regs" class="anchor"></a><code><span class="keyword">mutable</span> regs : <span><a href="Tval/index.html#type-t">Tval.t</a> <a href="Reg/Map/index.html#type-t">Reg.Map.t</a></span>;</code></td><td class="doc"><p>The values and types of registers</p></td></tr><tr id="type-t.read_vars" class="anchored"><td class="def field"><a href="#type-t.read_vars" class="anchor"></a><code>read_vars : <span><a href="Tval/index.html#type-t">Tval.t</a> <a href="../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</code></td><td class="doc"><p>The results of reads made since base state</p></td></tr><tr id="type-t.asserts" class="anchored"><td class="def field"><a href="#type-t.asserts" class="anchor"></a><code><span class="keyword">mutable</span> asserts : <span><a href="index.html#type-exp">exp</a> list</span>;</code></td><td class="doc"><p>Only asserts since base_state</p></td></tr><tr id="type-t.mem" class="anchored"><td class="def field"><a href="#type-t.mem" class="anchor"></a><code>mem : <a href="Mem/index.html#type-t">Mem.t</a>;</code></td></tr><tr id="type-t.elf" class="anchored"><td class="def field"><a href="#type-t.elf" class="anchor"></a><code>elf : <span><a href="../Elf/File/index.html#type-t">Elf.File.t</a> option</span>;</code></td><td class="doc"><p>Optionally an ELF file, this may be used when running instructions on the state to provide more concrete values in certain case (like when reading from <code>.rodata</code>). It will affect the execution behavior. However the symbolic execution should always be more concrete with it than without it</p></td></tr><tr id="type-t.fenv" class="anchored"><td class="def field"><a href="#type-t.fenv" class="anchor"></a><code>fenv : <a href="Fragment/index.html#type-env">Fragment.env</a>;</code></td><td class="doc"><p>The memory type environment. See <a href="Fragment/index.html#type-env"><code>Fragment.env</code></a></p></td></tr><tr id="type-t.last_pc" class="anchored"><td class="def field"><a href="#type-t.last_pc" class="anchor"></a><code><span class="keyword">mutable</span> last_pc : int;</code></td><td class="doc"><p>The PC of the instruction that lead into this state. The state should be right after that instruction. This has no semantic meaning as part of the state. It's just for helping knowing what comes from where</p></td></tr></table><code>}</code></dt><dd><p>Represent the state of the machine.</p><p>State are represented by their id and may identified to their id, they may not be two different state (and I mean physical equality here) with same id. See <a href="index.html#stateid"><span>State to id management</span></a>.</p><p>A first remark must be made about mutability: The type itself has an imperative interface, a lot of implicitly or explicitly mutable fields. However, Sometime immutable version of the state are required, so the state has a &quot;locking&quot; mechanism. When the <a href="index.html#type-t.locked"><code>locked</code></a> field, the state becomes immutable. This is unfortunately not enforced by the type system as that would require to have two different types. However all mutating functions assert that the state is unlocked before doing the mutation. The normal workflow with state is thus to create them unlocked, generaly by <a href="index.html#val-copy"><code>copy</code></a>ing another state, then mutate is to make a new interesting state, and then lock it so that it can be passed around for it's mathematical pure meaning. To lock a state, use the <a href="index.html#val-lock"><code>lock</code></a> function.</p><p>A second subtlety is that state are not represented in a standalone manner, They are represented as diff from a previous state, the <a href="index.html#type-t.base_state"><code>base_state</code></a>. In the idea, this state should be the immediate dominator of the current state in the control flow graph.However a state may not represent a full node of the control flow graph but only the part of that node that represent control-flow coming from specific paths. In that case the dominator notion is only about those paths.</p><p>Assertions (<a href="index.html#type-t.asserts"><code>asserts</code></a>) and memory (<a href="index.html#type-t.mem"><code>mem</code></a>) are represented as diffs from the base state. In particular all assertion constraining the base state are still constraining the child state.</p><p>This also implies a restriction on state dependent variables like <a href="Var/index.html#type-t.Register"><code>Var.t.Register</code></a>. The id of such variables can only be the id of the current state or one of it's ancestor. Further more if a variable of type <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> exists with and id and a number, then the <a href="index.html#type-t.read_vars"><code>read_vars</code></a> array of the state with that <code>id</code> must contain that number and the sizes must match. Those restriction are not only about semantic meaning but also more practical Ocaml Gc consideration, see <a href="index.html#stateid"><span>State to id management</span></a>.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt></dl></section><section><header><h2 id="stateid"><a href="#stateid" class="anchor"></a>State to id management</h2><p>Each state has an id and the state can be refereed physically by id. This mean that there cannot be two different physical Ocaml state in the Gc memory that have the same id. Furthermore the <a href="index.html#val-id2state"><code>id2state</code></a> map is weak and so do not own the state. This means that possession of an id is the same as having a weak pointer to the state, except for two things:</p><ul><li>The id can be serialized and read to external program and files without losing it's meaning.</li><li>The id allow to break cyclical type dependency.</li></ul><p>This is in particular useful for variable that contain and id instead of a pointer to the state:</p><ul><li>The variable can be serialized in text manner to a SMT solver and keep their meaning.</li><li>The <a href="Var/index.html#type-t"><code>Var.t</code></a> type can be defined before the <a href="index.html#type-t"><code>t</code></a> type.</li></ul><p>That means that in theory a state could be Garbage collected while a variable still point to it. However a variable is only allowed to exists in a state if the id it points to is among the ancestors via the <a href="index.html#type-t.base_state"><code>base_state</code></a> relationship of the containing state. Since <a href="index.html#type-t.base_state"><code>base_state</code></a> is an GC-owning pointer, this ensure that while the containing state is alive, the variable target state is also alive.</p></header><dl><dt class="spec value" id="val-id2state"><a href="#val-id2state" class="anchor"></a><code><span class="keyword">val</span> id2state : <span><span>(<a href="index.html#type-id">id</a>, <a href="index.html#type-t">t</a>)</span> <a href="../Utils/WeakMap/index.html#type-t">Utils.WeakMap.t</a></span></code></dt><dd><p>Global map of states to associate them with identifiers</p></dd></dl><dl><dt class="spec value" id="val-next_id"><a href="#val-next_id" class="anchor"></a><code><span class="keyword">val</span> next_id : <span><a href="index.html#type-id">id</a> Stdlib.ref</span></code></dt><dd><p>Next unused id</p></dd></dl><dl><dt class="spec value" id="val-of_id"><a href="#val-of_id" class="anchor"></a><code><span class="keyword">val</span> of_id : <a href="index.html#type-id">id</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get a state from its <code>id</code></p></dd></dl><dl><dt class="spec value" id="val-to_id"><a href="#val-to_id" class="anchor"></a><code><span class="keyword">val</span> to_id : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-id">id</a></code></dt><dd><p>Get the id of a state</p></dd></dl></section><section><header><h2 id="state-management"><a href="#state-management" class="anchor"></a>State management</h2></header><dl><dt class="spec value" id="val-lock"><a href="#val-lock" class="anchor"></a><code><span class="keyword">val</span> lock : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Lock the state. Once a state is locked it should not be mutated anymore</p></dd></dl><dl><dt class="spec value" id="val-unsafe_unlock"><a href="#val-unsafe_unlock" class="anchor"></a><code><span class="keyword">val</span> unsafe_unlock : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Unlock the state. This is dangerous, do not use if you do not know how to use it, The only realistic use case, is for calling a simplifier and thus not changing the semantic meaning of the state in any way while mutating it.</p><p>This is deprecated and should disappear at some point.</p></dd></dl><dl><dt class="spec value" id="val-is_locked"><a href="#val-is_locked" class="anchor"></a><code><span class="keyword">val</span> is_locked : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if the state is locked, in which case it shouldn't be mutated</p></dd></dl><dl><dt class="spec value" id="val-is_possible"><a href="#val-is_possible" class="anchor"></a><code><span class="keyword">val</span> is_possible : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell is state is possible.</p><p>A state is impossible if it has a single assert that is <code>false</code>. This means that this symbolic state represent the empty set of concrete states.</p><p><span class="xref-unresolved" title="unresolved reference to &quot;StateSimplify.ctxfull&quot;"><code>StateSimplify</code>.ctxfull</span> will call the SMT solver and set the assertions to that if required so you should call that function before <code>is_possible</code></p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;elf:<a href="../Elf/File/index.html#type-t">Elf.File.t</a></span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Makes a fresh state with all variable fresh and new. This fresh state is unlocked.</p><p>This should only be used by <code>Init</code>, all other state should be derived from <span class="xref-unresolved" title="unresolved reference to &quot;Init.state&quot;"><code>Init</code>.state</span>.</p></dd></dl><dl><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span>?&#8288;elf:<a href="../Elf/File/index.html#type-t">Elf.File.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Do a deep copy of all the mutable part of the state, so it can be mutated without retro-action.</p><p>If the source state is locked, then new state is based on it (in the sense of <a href="index.html#type-t.base_state"><code>t.base_state</code></a>), otherwise it is a literal copy of each field.</p><p>The returned state is always unlocked</p></dd></dl><dl><dt class="spec value" id="val-copy_if_locked"><a href="#val-copy_if_locked" class="anchor"></a><code><span class="keyword">val</span> copy_if_locked : <span>?&#8288;elf:<a href="../Elf/File/index.html#type-t">Elf.File.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Copy the state with <a href="index.html#val-copy"><code>copy</code></a> if and only if it is locked. The returned state is always unlocked</p></dd></dl></section><section><header><h2 id="state-convenience-manipulation"><a href="#state-convenience-manipulation" class="anchor"></a>State convenience manipulation</h2></header><dl><dt class="spec value" id="val-push_assert"><a href="#val-push_assert" class="anchor"></a><code><span class="keyword">val</span> push_assert : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add an assertion to a state</p></dd></dl><dl><dt class="spec value" id="val-set_impossible"><a href="#val-set_impossible" class="anchor"></a><code><span class="keyword">val</span> set_impossible : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a state to be impossible (single <code>false</code> assert).</p></dd></dl><dl><dt class="spec value" id="val-set_asserts"><a href="#val-set_asserts" class="anchor"></a><code><span class="keyword">val</span> set_asserts : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a state's <code>asserts</code></p></dd></dl><dl><dt class="spec value" id="val-map_mut_exp"><a href="#val-map_mut_exp" class="anchor"></a><code><span class="keyword">val</span> map_mut_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map a function on all the expressions of a state by mutating. This function, must preserve the semantic meaning of expression (like a simplification function) otherwise state invariants may be broken.</p></dd></dl><dl><dt class="spec value" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span class="keyword">val</span> iter_exp : <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterates a function on all the expressions of a state</p></dd></dl><dl><dt class="spec value" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span class="keyword">val</span> iter_var : <span>(<a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterates a function on all the variables of a state</p></dd></dl></section><section><header><h2 id="state-memory-accessors"><a href="#state-memory-accessors" class="anchor"></a>State memory accessors</h2></header><dl><dt class="spec value" id="val-make_read"><a href="#val-make_read" class="anchor"></a><code><span class="keyword">val</span> make_read : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>?&#8288;ctyp:<a href="../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a></code></dt><dd><p>Create a new <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> by mutating the state</p></dd></dl><dl><dt class="spec value" id="val-set_read"><a href="#val-set_read" class="anchor"></a><code><span class="keyword">val</span> set_read : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a <a href="Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> to a specific value in <a href="index.html#type-t.read_vars"><code>t.read_vars</code></a></p></dd></dl><dl><dt class="spec value" id="val-read_from_rodata"><a href="#val-read_from_rodata" class="anchor"></a><code><span class="keyword">val</span> read_from_rodata : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> option</span></code></dt><dd><p>Read memory from rodata</p></dd></dl><dl><dt class="spec value" id="val-read"><a href="#val-read" class="anchor"></a><code><span class="keyword">val</span> read : <span>provenance:<a href="../Ctype/index.html#type-provenance">Ctype.provenance</a></span> <span>&#45;&gt;</span> <span>?&#8288;ctyp:<a href="../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Read the block designated by <code>addr</code> and <code>size</code> from the state and return an expression read. This will mutate the state to bind the read result to the newly created read variable.</p><p>The <code>ctyp</code> parameter may give a type to the read variable. This type is fully trusted and not checked in any way.</p><p>The expression could be either:</p><ul><li>An actual expression if the read could be resolved.</li><li>Just the symbolic read variable if the read couldn't be resolved</li></ul><p>This function is for case with <code>provenance</code> information is known.</p></dd></dl><dl><dt class="spec value" id="val-read_noprov"><a href="#val-read_noprov" class="anchor"></a><code><span class="keyword">val</span> read_noprov : <span>?&#8288;ctyp:<a href="../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>A wrapper around <a href="index.html#val-read"><code>read</code></a> for use when there is no provenance information. It may able to still perform the read under certain condition and otherwise will fail.</p></dd></dl><dl><dt class="spec value" id="val-write"><a href="#val-write" class="anchor"></a><code><span class="keyword">val</span> write : <span>provenance:<a href="../Ctype/index.html#type-provenance">Ctype.provenance</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write the provided value in the block. Mutate the state.</p></dd></dl><dl><dt class="spec value" id="val-write_noprov"><a href="#val-write_noprov" class="anchor"></a><code><span class="keyword">val</span> write_noprov : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>addr:<a href="index.html#type-exp">exp</a></span> <span>&#45;&gt;</span> <span>size:<a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>A wrapper around <a href="index.html#val-write"><code>write</code></a> for use when there is no provenance information. It may able to still perform the write under certain condition and otherwise will fail.</p></dd></dl></section><section><header><h2 id="state-register-accessors"><a href="#state-register-accessors" class="anchor"></a>State register accessors</h2></header><dl><dt class="spec value" id="val-reset_reg"><a href="#val-reset_reg" class="anchor"></a><code><span class="keyword">val</span> reset_reg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>?&#8288;ctyp:<a href="../Ctype/index.html#type-t">Ctype.t</a></span> <span>&#45;&gt;</span> <a href="Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Reset the register to a symbolic value, and resets the type to the provided type (or no type if not provided)</p></dd></dl><dl><dt class="spec value" id="val-set_reg"><a href="#val-set_reg" class="anchor"></a><code><span class="keyword">val</span> set_reg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-tval">tval</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Sets the content of register</p></dd></dl><dl><dt class="spec value" id="val-set_reg_type"><a href="#val-set_reg_type" class="anchor"></a><code><span class="keyword">val</span> set_reg_type : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="../Ctype/index.html#type-t">Ctype.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Sets the type of the register, leaves the value unchanged</p></dd></dl><dl><dt class="spec value" id="val-get_reg"><a href="#val-get_reg" class="anchor"></a><code><span class="keyword">val</span> get_reg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-tval">tval</a></code></dt><dd><p>Get the content of the register with it's type</p></dd></dl><dl><dt class="spec value" id="val-get_reg_exp"><a href="#val-get_reg_exp" class="anchor"></a><code><span class="keyword">val</span> get_reg_exp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Get the content of the register without it's type</p></dd></dl><dl><dt class="spec value" id="val-update_reg_exp"><a href="#val-update_reg_exp" class="anchor"></a><code><span class="keyword">val</span> update_reg_exp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <span>(<a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a>)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Apply a function to a register. Leave the type intact</p></dd></dl></section><section><header><h2 id="pc-manipulation"><a href="#pc-manipulation" class="anchor"></a>Pc manipulation</h2></header><dl><dt class="spec value" id="val-set_pc"><a href="#val-set_pc" class="anchor"></a><code><span class="keyword">val</span> set_pc : <span>pc:<a href="Reg/index.html#type-t">Reg.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the PC to a concrete value and keep its type appropriate</p></dd></dl><dl><dt class="spec value" id="val-bump_pc"><a href="#val-bump_pc" class="anchor"></a><code><span class="keyword">val</span> bump_pc : <span>pc:<a href="Reg/index.html#type-t">Reg.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Bump a concrete PC by a concrete bump (generally the size of a non-branching instruction</p></dd></dl><dl><dt class="spec value" id="val-concretize_pc"><a href="#val-concretize_pc" class="anchor"></a><code><span class="keyword">val</span> concretize_pc : <span>pc:<a href="Reg/index.html#type-t">Reg.t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Try to evaluate the PC if it is concrete</p></dd></dl><dl><dt class="spec value" id="val-set_last_pc"><a href="#val-set_last_pc" class="anchor"></a><code><span class="keyword">val</span> set_last_pc : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the <code>last_pc</code> of the state</p></dd></dl></section><section><header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2></header><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-pp_partial"><a href="#val-pp_partial" class="anchor"></a><code><span class="keyword">val</span> pp_partial : <span>regs:<span><a href="Reg/index.html#type-t">Reg.t</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Print only the mentioned regs and the memory and asserts since the base_state. Until a better solution is found, the fenv will be printed entirely all the time</p></dd></dl></section></details></div></div></div><dl><dt class="spec module" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span class="keyword">module</span> <a href="Base/index.html">Base</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module introduce a type to represent the state of the machine.</p></dd></dl><dl><dt class="spec module" id="module-Fragment"><a href="#module-Fragment" class="anchor"></a><code><span class="keyword">module</span> <a href="Fragment/index.html">Fragment</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module define a memory fragment to be used by C types</p></dd></dl><dl><dt class="spec module" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span class="keyword">module</span> <a href="Reg/index.html">Reg</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module handle the register abstraction.</p></dd></dl><dl><dt class="spec module" id="module-Simplify"><a href="#module-Simplify" class="anchor"></a><code><span class="keyword">module</span> <a href="Simplify/index.html">Simplify</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide utility to simplify states</p></dd></dl><dl><dt class="spec module" id="module-SymbolicBytes"><a href="#module-SymbolicBytes" class="anchor"></a><code><span class="keyword">module</span> <a href="SymbolicBytes/index.html">SymbolicBytes</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide high-level support for a symbolic array of bytes.</p></dd></dl><div class="spec module" id="module-SymbolicFragement"><a href="#module-SymbolicFragement" class="anchor"></a><code><span class="keyword">module</span> SymbolicFragement = <a href="../State__/index.html#module-SymbolicFragment">State__.SymbolicFragment</a></code></div><dl><dt class="spec module" id="module-Tree"><a href="#module-Tree" class="anchor"></a><code><span class="keyword">module</span> <a href="Tree/index.html">Tree</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provides a tree of state to represent an unmerged execution</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>State (read-dwarf.State)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; State</nav><header class="odoc-preamble"><h1>Module <code><span>State</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="Base/index.html">Base</a> <span class="keyword">end</span></span></code></summary><h2 id="state-id"><a href="#state-id" class="anchor"></a>State id</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Id"><a href="#module-Id" class="anchor"></a><code><span><span class="keyword">module</span> Id</span><span> = <a href="Base/Id/index.html">Base.Id</a></span></code></div><div class="spec-doc"><p>The type of a state ID. for now it's an integer, but it may change later In particular whether a state belong to O0 or O2 may be part of the <code>id</code> at some point.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-id"><a href="#type-id" class="anchor"></a><code><span><span class="keyword">type</span> id</span><span> = <a href="Base/Id/index.html#type-t">Id.t</a></span></code></div></div><h2 id="state-variable-management"><a href="#state-variable-management" class="anchor"></a>State variable management</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span><span class="keyword">module</span> Var</span><span> = <a href="Base/Var/index.html">Base.Var</a></span></code></div><div class="spec-doc"><p>This module provide state variables. Those are all symbolic variables that may appear in a state. If the same (in the <a href="Base/Var/index.html#val-equal"><code>Var.equal</code></a> sense) variable appear in two state, that mean that when considered together, there is an implicit relation between them.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="Base/Var/index.html#type-t">Var.t</a></span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><h2 id="state-expression-and-typed-value-management"><a href="#state-expression-and-typed-value-management" class="anchor"></a>State expression and typed-value management</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span><span class="keyword">module</span> Exp</span><span> = <a href="Base/Exp/index.html">Base.Exp</a></span></code></div><div class="spec-doc"><p>Module for state expressions</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <a href="Base/Exp/index.html#type-t">Exp.t</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Tval"><a href="#module-Tval" class="anchor"></a><code><span><span class="keyword">module</span> Tval</span><span> = <a href="Base/Tval/index.html">Base.Tval</a></span></code></div><div class="spec-doc"><p>Module for optionally typed state expressions. Those are symbolic values which may or may not have a C type.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-tval"><a href="#type-tval" class="anchor"></a><code><span><span class="keyword">type</span> tval</span><span> = <a href="Base/Tval/index.html#type-t">Tval.t</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Relocation"><a href="#module-Relocation" class="anchor"></a><code><span><span class="keyword">module</span> Relocation</span><span> = <a href="Base/Relocation/index.html">Base.Relocation</a></span></code></div></div><h2 id="state-memory-management"><a href="#state-memory-management" class="anchor"></a>State memory management</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Mem"><a href="#module-Mem" class="anchor"></a><code><span><span class="keyword">module</span> Mem</span><span> = <a href="Base/Mem/index.html">Base.Mem</a></span></code></div><div class="spec-doc"><p>This module manages the memory part of the state.</p></div></div><h2 id="state-type"><a href="#state-type" class="anchor"></a>State type</h2><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span class="keyword">private</span> <a href="Base/index.html#type-t">Base.t</a></span><span> = </span><span>{</span></code><ol><li id="type-t.id" class="def record field anchored"><a href="#type-t.id" class="anchor"></a><code><span>id : <a href="#type-id">id</a>;</span></code></li><li id="type-t.base_state" class="def record field anchored"><a href="#type-t.base_state" class="anchor"></a><code><span>base_state : <span><a href="#type-t">t</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The immediate dominator state in the control flow graph</p><span class="comment-delim">*)</span></div></li><li id="type-t.locked" class="def record field anchored"><a href="#type-t.locked" class="anchor"></a><code><span><span class="keyword">mutable</span> locked : bool;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Tells if the state is locked</p><span class="comment-delim">*)</span></div></li><li id="type-t.regs" class="def record field anchored"><a href="#type-t.regs" class="anchor"></a><code><span><span class="keyword">mutable</span> regs : <span><a href="Base/Tval/index.html#type-t">Tval.t</a> <a href="Reg/Map/index.html#type-t">Reg.Map.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The values and types of registers</p><span class="comment-delim">*)</span></div></li><li id="type-t.read_vars" class="def record field anchored"><a href="#type-t.read_vars" class="anchor"></a><code><span>read_vars : <span><a href="Base/Tval/index.html#type-t">Tval.t</a> <a href="../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The results of reads made since base state</p><span class="comment-delim">*)</span></div></li><li id="type-t.asserts" class="def record field anchored"><a href="#type-t.asserts" class="anchor"></a><code><span><span class="keyword">mutable</span> asserts : <span><a href="#type-exp">exp</a> list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Only asserts since base_state</p><span class="comment-delim">*)</span></div></li><li id="type-t.relocation_asserts" class="def record field anchored"><a href="#type-t.relocation_asserts" class="anchor"></a><code><span><span class="keyword">mutable</span> relocation_asserts : <span><a href="#type-exp">exp</a> list</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Only asserts since base_state</p><span class="comment-delim">*)</span></div></li><li id="type-t.mem" class="def record field anchored"><a href="#type-t.mem" class="anchor"></a><code><span>mem : <a href="Base/Mem/index.html#type-t">Mem.t</a>;</span></code></li><li id="type-t.elf" class="def record field anchored"><a href="#type-t.elf" class="anchor"></a><code><span>elf : <span><a href="../Elf/File/index.html#type-t">Elf.File.t</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Optionally an ELF file, this may be used when running instructions on the state to provide more concrete values in certain case (like when reading from <code>.rodata</code>). It will affect the execution behavior. However the symbolic execution should always be more concrete with it than without it</p><span class="comment-delim">*)</span></div></li><li id="type-t.fenv" class="def record field anchored"><a href="#type-t.fenv" class="anchor"></a><code><span>fenv : <a href="Fragment/index.html#type-env">Fragment.env</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The memory type environment. See <a href="Fragment/index.html#type-env"><code>Fragment.env</code></a></p><span class="comment-delim">*)</span></div></li><li id="type-t.last_pc" class="def record field anchored"><a href="#type-t.last_pc" class="anchor"></a><code><span><span class="keyword">mutable</span> last_pc : <a href="../Elf/Address/index.html#type-t">Elf.Address.t</a>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The PC of the instruction that lead into this state. The state should be right after that instruction. This has no semantic meaning as part of the state. It's just for helping knowing what comes from where</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>Represent the state of the machine.</p><p>State are represented by their id and may identified to their id, they may not be two different state (and I mean physical equality here) with same id. See <a href="#stateid" title="stateid">State to id management</a>.</p><p>A first remark must be made about mutability: The type itself has an imperative interface, a lot of implicitly or explicitly mutable fields. However, Sometime immutable version of the state are required, so the state has a &quot;locking&quot; mechanism. When the <a href="#type-t.locked"><code>locked</code></a> field, the state becomes immutable. This is unfortunately not enforced by the type system as that would require to have two different types. However all mutating functions assert that the state is unlocked before doing the mutation. The normal workflow with state is thus to create them unlocked, generaly by <a href="#val-copy"><code>copy</code></a>ing another state, then mutate is to make a new interesting state, and then lock it so that it can be passed around for it's mathematical pure meaning. To lock a state, use the <a href="#val-lock"><code>lock</code></a> function.</p><p>A second subtlety is that state are not represented in a standalone manner, They are represented as diff from a previous state, the <a href="#type-t.base_state"><code>base_state</code></a>. In the idea, this state should be the immediate dominator of the current state in the control flow graph.However a state may not represent a full node of the control flow graph but only the part of that node that represent control-flow coming from specific paths. In that case the dominator notion is only about those paths.</p><p>Assertions (<a href="#type-t.asserts"><code>asserts</code></a>) and memory (<a href="#type-t.mem"><code>mem</code></a>) are represented as diffs from the base state. In particular all assertion constraining the base state are still constraining the child state.</p><p>This also implies a restriction on state dependent variables like <a href="Base/Var/index.html#type-t.Register"><code>Var.t.Register</code></a>. The id of such variables can only be the id of the current state or one of it's ancestor. Further more if a variable of type <a href="Base/Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> exists with and id and a number, then the <a href="#type-t.read_vars"><code>read_vars</code></a> array of the state with that <code>id</code> must contain that number and the sizes must match. Those restriction are not only about semantic meaning but also more practical Ocaml Gc consideration, see <a href="#stateid" title="stateid">State to id management</a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><h2 id="stateid"><a href="#stateid" class="anchor"></a>State to id management</h2><p>Each state has an id and the state can be refereed physically by id. This mean that there cannot be two different physical Ocaml state in the Gc memory that have the same id. Furthermore the <a href="#val-id2state"><code>id2state</code></a> map is weak and so do not own the state. This means that possession of an id is the same as having a weak pointer to the state, except for two things:</p><ul><li>The id can be serialized and read to external program and files without losing it's meaning.</li><li>The id allow to break cyclical type dependency.</li></ul><p>This is in particular useful for variable that contain and id instead of a pointer to the state:</p><ul><li>The variable can be serialized in text manner to a SMT solver and keep their meaning.</li><li>The <a href="Base/Var/index.html#type-t"><code>Var.t</code></a> type can be defined before the <a href="#type-t"><code>t</code></a> type.</li></ul><p>That means that in theory a state could be Garbage collected while a variable still point to it. However a variable is only allowed to exists in a state if the id it points to is among the ancestors via the <a href="#type-t.base_state"><code>base_state</code></a> relationship of the containing state. Since <a href="#type-t.base_state"><code>base_state</code></a> is an GC-owning pointer, this ensure that while the containing state is alive, the variable target state is also alive.</p><div class="odoc-spec"><div class="spec value anchored" id="val-id2state"><a href="#val-id2state" class="anchor"></a><code><span><span class="keyword">val</span> id2state : <span><span>(<a href="#type-id">id</a>, <a href="#type-t">t</a>)</span> <a href="../Utils/WeakMap/index.html#type-t">Utils.WeakMap.t</a></span></span></code></div><div class="spec-doc"><p>Global map of states to associate them with identifiers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-next_id"><a href="#val-next_id" class="anchor"></a><code><span><span class="keyword">val</span> next_id : <span><a href="#type-id">id</a> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>Next unused id</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_id"><a href="#val-of_id" class="anchor"></a><code><span><span class="keyword">val</span> of_id : <span><a href="#type-id">id</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get a state from its <code>id</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_id"><a href="#val-to_id" class="anchor"></a><code><span><span class="keyword">val</span> to_id : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-id">id</a></span></code></div><div class="spec-doc"><p>Get the id of a state</p></div></div><h2 id="state-management"><a href="#state-management" class="anchor"></a>State management</h2><div class="odoc-spec"><div class="spec value anchored" id="val-lock"><a href="#val-lock" class="anchor"></a><code><span><span class="keyword">val</span> lock : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Lock the state. Once a state is locked it should not be mutated anymore</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_unlock"><a href="#val-unsafe_unlock" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_unlock : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Unlock the state. This is dangerous, do not use if you do not know how to use it, The only realistic use case, is for calling a simplifier and thus not changing the semantic meaning of the state in any way while mutating it.</p><p>This is deprecated and should disappear at some point.</p><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> Stop unlocking states</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_locked"><a href="#val-is_locked" class="anchor"></a><code><span><span class="keyword">val</span> is_locked : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if the state is locked, in which case it shouldn't be mutated</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_possible"><a href="#val-is_possible" class="anchor"></a><code><span><span class="keyword">val</span> is_possible : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell is state is possible.</p><p>A state is impossible if it has a single assert that is <code>false</code>. This means that this symbolic state represent the empty set of concrete states.</p><p><code>StateSimplify.ctxfull</code> will call the SMT solver and set the assertions to that if required so you should call that function before <code>is_possible</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?elf</span>:<a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Makes a fresh state with all variable fresh and new. This fresh state is unlocked.</p><p>This should only be used by <code>Init</code>, all other state should be derived from <code>Init.state</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span class="optlabel">?elf</span>:<a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Do a deep copy of all the mutable part of the state, so it can be mutated without retro-action.</p><p>If the source state is locked, then new state is based on it (in the sense of <a href="#type-t.base_state"><code>t.base_state</code></a>), otherwise it is a literal copy of each field.</p><p>The returned state is always unlocked</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy_if_locked"><a href="#val-copy_if_locked" class="anchor"></a><code><span><span class="keyword">val</span> copy_if_locked : <span><span class="optlabel">?elf</span>:<a href="../Elf/File/index.html#type-t">Elf.File.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Copy the state with <a href="#val-copy"><code>copy</code></a> if and only if it is locked. The returned state is always unlocked</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init_sections"><a href="#val-init_sections" class="anchor"></a><code><span><span class="keyword">val</span> init_sections : <span><span class="label">sp</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <a href="Reg/index.html#type-t">Reg.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr_size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init_sections_symbolic"><a href="#val-init_sections_symbolic" class="anchor"></a><code><span><span class="keyword">val</span> init_sections_symbolic : <span><span class="label">sp</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <a href="Reg/index.html#type-t">Reg.t</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr_size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Assigns all sections with global objects to Main fragment</p></div></div><h2 id="state-convenience-manipulation"><a href="#state-convenience-manipulation" class="anchor"></a>State convenience manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-push_assert"><a href="#val-push_assert" class="anchor"></a><code><span><span class="keyword">val</span> push_assert : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add an assertion to a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-push_relocation_assert"><a href="#val-push_relocation_assert" class="anchor"></a><code><span><span class="keyword">val</span> push_relocation_assert : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add an assertion to a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_impossible"><a href="#val-set_impossible" class="anchor"></a><code><span><span class="keyword">val</span> set_impossible : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a state to be impossible (single <code>false</code> assert).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_asserts"><a href="#val-set_asserts" class="anchor"></a><code><span><span class="keyword">val</span> set_asserts : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a state's <code>asserts</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut_exp"><a href="#val-map_mut_exp" class="anchor"></a><code><span><span class="keyword">val</span> map_mut_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map a function on all the expressions of a state by mutating. This function, must preserve the semantic meaning of expression (like a simplification function) otherwise state invariants may be broken.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_exp"><a href="#val-iter_exp" class="anchor"></a><code><span><span class="keyword">val</span> iter_exp : <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterates a function on all the expressions of a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span><span class="keyword">val</span> iter_var : <span><span>(<span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterates a function on all the variables of a state</p></div></div><h2 id="state-memory-accessors"><a href="#state-memory-accessors" class="anchor"></a>State memory accessors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-make_read"><a href="#val-make_read" class="anchor"></a><code><span><span class="keyword">val</span> make_read : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?ctyp</span>:<a href="../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-var">var</a></span></code></div><div class="spec-doc"><p>Create a new <a href="Base/Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> by mutating the state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_read"><a href="#val-set_read" class="anchor"></a><code><span><span class="keyword">val</span> set_read : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a <a href="Base/Var/index.html#type-t.ReadVar"><code>Var.t.ReadVar</code></a> to a specific value in <a href="#type-t.read_vars"><code>t.read_vars</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_from_rodata"><a href="#val-read_from_rodata" class="anchor"></a><code><span><span class="keyword">val</span> read_from_rodata : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:<a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> option</span></span></code></div><div class="spec-doc"><p>Read memory from rodata</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read"><a href="#val-read" class="anchor"></a><code><span><span class="keyword">val</span> read : 
+  <span><span class="label">provenance</span>:<a href="../Ctype/index.html#type-provenance">Ctype.provenance</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?ctyp</span>:<a href="../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">size</span>:<a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Read the block designated by <code>addr</code> and <code>size</code> from the state and return an expression read. This will mutate the state to bind the read result to the newly created read variable.</p><p>The <code>ctyp</code> parameter may give a type to the read variable. This type is fully trusted and not checked in any way.</p><p>The expression could be either:</p><ul><li>An actual expression if the read could be resolved.</li><li>Just the symbolic read variable if the read couldn't be resolved</li></ul><p>This function is for case with <code>provenance</code> information is known.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_noprov"><a href="#val-read_noprov" class="anchor"></a><code><span><span class="keyword">val</span> read_noprov : <span><span class="optlabel">?ctyp</span>:<a href="../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:<a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>A wrapper around <a href="#val-read"><code>read</code></a> for use when there is no provenance information. It may able to still perform the read under certain condition and otherwise will fail.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write"><a href="#val-write" class="anchor"></a><code><span><span class="keyword">val</span> write : 
+  <span><span class="label">provenance</span>:<a href="../Ctype/index.html#type-provenance">Ctype.provenance</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">size</span>:<a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Write the provided value in the block. Mutate the state.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_noprov"><a href="#val-write_noprov" class="anchor"></a><code><span><span class="keyword">val</span> write_noprov : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">addr</span>:<a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:<a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>A wrapper around <a href="#val-write"><code>write</code></a> for use when there is no provenance information. It may able to still perform the write under certain condition and otherwise will fail.</p></div></div><h2 id="state-register-accessors"><a href="#state-register-accessors" class="anchor"></a>State register accessors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-reset_reg"><a href="#val-reset_reg" class="anchor"></a><code><span><span class="keyword">val</span> reset_reg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?ctyp</span>:<a href="../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Reset the register to a symbolic value, and resets the type to the provided type (or no type if not provided)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_reg"><a href="#val-set_reg" class="anchor"></a><code><span><span class="keyword">val</span> set_reg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-tval">tval</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Sets the content of register</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_reg_type"><a href="#val-set_reg_type" class="anchor"></a><code><span><span class="keyword">val</span> set_reg_type : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Ctype/index.html#type-t">Ctype.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Sets the type of the register, leaves the value unchanged</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_reg"><a href="#val-get_reg" class="anchor"></a><code><span><span class="keyword">val</span> get_reg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-tval">tval</a></span></code></div><div class="spec-doc"><p>Get the content of the register with it's type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_reg_exp"><a href="#val-get_reg_exp" class="anchor"></a><code><span><span class="keyword">val</span> get_reg_exp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Get the content of the register without it's type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update_reg_exp"><a href="#val-update_reg_exp" class="anchor"></a><code><span><span class="keyword">val</span> update_reg_exp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Apply a function to a register. Leave the type intact</p></div></div><h2 id="pc-manipulation"><a href="#pc-manipulation" class="anchor"></a>Pc manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-set_pc"><a href="#val-set_pc" class="anchor"></a><code><span><span class="keyword">val</span> set_pc : <span><span class="label">pc</span>:<a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the PC to a concrete value and keep its type appropriate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_pc_sym"><a href="#val-set_pc_sym" class="anchor"></a><code><span><span class="keyword">val</span> set_pc_sym : <span><span class="label">pc</span>:<a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bump_pc"><a href="#val-bump_pc" class="anchor"></a><code><span><span class="keyword">val</span> bump_pc : <span><span class="label">pc</span>:<a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Bump a concrete PC by a concrete bump (generally the size of a non-branching instruction</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concretize_pc"><a href="#val-concretize_pc" class="anchor"></a><code><span><span class="keyword">val</span> concretize_pc : <span><span class="label">pc</span>:<a href="Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Try to evaluate the PC if it is concrete</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_last_pc"><a href="#val-set_last_pc" class="anchor"></a><code><span><span class="keyword">val</span> set_last_pc : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Elf/Address/index.html#type-t">Elf.Address.t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the <code>last_pc</code> of the state</p></div></div><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_partial"><a href="#val-pp_partial" class="anchor"></a><code><span><span class="keyword">val</span> pp_partial : <span><span class="label">regs</span>:<span><a href="Reg/index.html#type-t">Reg.t</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Print only the mentioned regs and the memory and asserts since the base_state. Until a better solution is found, the fenv will be printed entirely all the time</p></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Base/index.html">Base</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module introduce a type to represent the state of the machine.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Fragment"><a href="#module-Fragment" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Fragment/index.html">Fragment</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module define a memory fragment to be used by C types</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Reg/index.html">Reg</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module handle the register abstraction.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Simplify"><a href="#module-Simplify" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Simplify/index.html">Simplify</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide utility to simplify states</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SymbolicBytes"><a href="#module-SymbolicBytes" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SymbolicBytes/index.html">SymbolicBytes</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide high-level support for a symbolic array of bytes.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SymbolicFragement"><a href="#module-SymbolicFragement" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SymbolicFragement/index.html">SymbolicFragement</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides a representation of symbolic memory as both a trace and a caching mechanism That is able to fetch some actual read value when there is no risk of aliasing.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Tree"><a href="#module-Tree" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Tree/index.html">Tree</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides a tree of state to represent an unmerged execution</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/SymbolicExecution.html b/doc/html/read-dwarf/SymbolicExecution.html
index aee42b2e..43a2e807 100644
--- a/doc/html/read-dwarf/SymbolicExecution.html
+++ b/doc/html/read-dwarf/SymbolicExecution.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymbolicExecution (read-dwarf.SymbolicExecution)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; SymbolicExecution</nav><h1 id="symbolic-execution"><a href="#symbolic-execution" class="anchor"></a>Symbolic Execution</h1><p>This page decribe the general method for symbolically running code in <code>read-dwarf</code>.</p><p>To run instructions on a state, you must first get the instruction semantics trough the <span class="xref-unresolved" title="unresolved reference to &quot;Isla.Pipeline&quot;"><span>Isla pipeline</span></span>. Then you can run trace individually using <a href="Trace/Run/index.html"><code>Trace.Run</code></a> module or do it all automatically using the <a href="Run/Runner/index.html"><code>Run.Runner</code></a>.</p><p>To run entire block of instruction there is the legacy <a href="Run/BB/index.html"><code>Run.BB</code></a> to run a branchless and jumpless basic block and <a href="Run/Block/index.html"><code>Run.Block</code></a> to run a complete block of code with control-flow. <a href="Run/Block/index.html"><code>Run.Block</code></a> will output a tree of the possibilities, but is still quite basic. There is no need for fancier generic way of running block of instruction as the actual order of running thing will be choosen by the simulation finding code that is not yet written.</p></header></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymbolicExecution (read-dwarf.SymbolicExecution)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; SymbolicExecution</nav><header class="odoc-preamble"><h1 id="symbolic-execution"><a href="#symbolic-execution" class="anchor"></a>Symbolic Execution</h1><p>This page decribe the general method for symbolically running code in <code>read-dwarf</code>.</p><p>To run instructions on a state, you must first get the instruction semantics trough the <span class="xref-unresolved" title="Isla.Pipeline">Isla pipeline</span>. Then you can run trace individually using <a href="Trace/Run/index.html"><code>Trace.Run</code></a> module or do it all automatically using the <a href="Run/Runner/index.html"><code>Run.Runner</code></a>.</p><p>To run entire block of instruction there is the legacy <a href="Run/BB/index.html"><code>Run.BB</code></a> to run a branchless and jumpless basic block and <a href="Run/Block/index.html"><code>Run.Block</code></a> to run a complete block of code with control-flow. <a href="Run/Block/index.html"><code>Run.Block</code></a> will output a tree of the possibilities, but is still quite basic. There is no need for fancier generic way of running block of instruction as the actual order of running thing will be choosen by the simulation finding code that is not yet written.</p></header><div class="odoc-content"></div></body></html>
diff --git a/doc/html/read-dwarf/SymbolicExpressions.html b/doc/html/read-dwarf/SymbolicExpressions.html
index 603979ff..67095228 100644
--- a/doc/html/read-dwarf/SymbolicExpressions.html
+++ b/doc/html/read-dwarf/SymbolicExpressions.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymbolicExpressions (read-dwarf.SymbolicExpressions)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; SymbolicExpressions</nav><h1 id="symbolic-expressions"><a href="#symbolic-expressions" class="anchor"></a>Symbolic Expressions</h1><nav class="toc"><ul><li><a href="#expression-representation-and-parametric-types">Expression representation and parametric types</a><ul><li><a href="#build-process-and-modules">Build process and modules</a></li><li><a href="#typopt">Expression type parameter and options</a></li></ul></li><li><a href="#operations-on-expressions">Operations on expressions</a></li><li><a href="#symbolic-regions-of-memory">Symbolic regions of memory</a></li></ul></nav></header><h2 id="expression-representation-and-parametric-types"><a href="#expression-representation-and-parametric-types" class="anchor"></a>Expression representation and parametric types</h2><p>The internal expression syntax is derived from <a href="http://smtlib.cs.uiowa.edu/">SMT-LIB</a> with the bitvector, boolean, and enumeration theory. The enumeration theory is about types that contain a specific number of numbered item. All the symbolic execution system is based of those expressions.</p><p>Optionally, an expression can support the whole memory through the SMT array theory from addresses to bytes or words. This support is optional, see <a href="SymbolicExpressions.html#typopt"><span>Expression type parameter and options</span></a></p><p>If you only wish to use those expression, I recommend you directly use the <a href="Ast/index.html"><code>Ast</code></a> module. This module export <a href="Ast/index.html#type-exp"><code>Ast.exp</code></a> as well as parsing and pretty printing capabilities.</p><p>The <a href="Ast/index.html"><code>Ast</code></a> module also define the syntax for SMT-LIB commands (<a href="Ast/index.html#type-smt"><code>Ast.smt</code></a>), and answers (<a href="Ast/index.html#type-smt_ans"><code>Ast.smt_ans</code></a>).</p><h3 id="build-process-and-modules"><a href="#build-process-and-modules" class="anchor"></a>Build process and modules</h3><p>The expressions types are build by <code>ott</code>. Currently, to avoid repetition, part of the <code>ott</code> AST comes from <code>isla_lang.ott</code> and only the difference with <code>isla-lang</code> are coming from the main <code>ast.ott</code> file. Only specific parts of <code>isla_lang.ott</code> are extracted with <code>extract_section.awk</code> before merging with <code>ast.ott</code>. The result of the call to <code>ott</code> are:</p><ul><li><a href="AstGen/Ott/index.html"><code>AstGen.Ott</code></a> that defined the ast types</li><li><a href="AstGen/Parser/index.html"><code>AstGen.Parser</code></a> The menhir parser module</li><li><a href="AstGen/Parser_pp/index.html"><code>AstGen.Parser_pp</code></a> The pprint pretty-printing module</li><li><a href="AstGen/Lexer/index.html"><code>AstGen.Lexer</code></a> The ocamllex lexer module</li></ul><p>One thing to be aware of is the dependency chain: first <a href="AstGen/Ott/index.html"><code>AstGen.Ott</code></a> is defined, then <a href="AstGen/Def/index.html"><code>AstGen.Def</code></a> (which is not generated) defines dome extra type definition to be used, then all the parsing and pretty printing module depend on <a href="AstGen/Def/index.html"><code>AstGen.Def</code></a> and then <a href="Ast/index.html"><code>Ast</code></a> encapsulates all of that for the rest of the codebase.</p><p>Unless you are tweaking things inside the AST, you should only use the <a href="Ast/index.html"><code>Ast</code></a> module.</p><h3 id="typopt"><a href="#typopt" class="anchor"></a>Expression type parameter and options</h3><p>The type of expression (<a href="Ast/index.html#type-exp"><code>Ast.exp</code></a>) is parametric and has currently 4 parameters that are propagated to other <a href="Ast/index.html"><code>Ast</code></a> types. Some <a href="Ast/index.html"><code>Ast</code></a> types only have a subset of those parameters when it make sense. It would be good to respect the variable letter names throughout the codebase to keep it consistent and understandable.</p><ul><li><code>'a</code>: Annotation type: The annotation is present on every expression constructor, and can be extracted with <span class="xref-unresolved" title="unresolved reference to &quot;Ast.Manip.annot&quot;"><a href="Ast/index.html#module-Manip"><code>Ast.Manip</code></a>.annot</span></li><li><code>'v</code>: Variable type: The type of symbolic variables.</li><li><code>'b</code>: Bound variable type: The expression can optionally contain let bindings and bound variables with the usual semantics. This feature of expression can be disabled by putting <a href="Ast/index.html#type-no"><code>Ast.no</code></a> in that parameter slot, in which case all let-bindings constructors and bound variable (<code>Let</code> and <code>Bound</code>) are disabled.</li><li><code>'m</code>: Memory operation: This is intended to be a boolean option: only <a href="Ast/Size/index.html#type-t"><code>Ast.Size.t</code></a> or <a href="Ast/index.html#type-no"><code>Ast.no</code></a>. In the first case, expression are allowed to contain memory array type and contain constructors like memory select or store. In the second case, all those operations are disabled and it is known that an expression can only be a bitvector, a boolean or an enumeration. In particular the content of register should generally not contain memory-enabled expressions.</li></ul><p>Expression coming out of the parser have their type parameter fixed to <code>'a=</code><a href="Ast/index.html#type-lrng"><code>Ast.lrng</code></a>, <code>'v=string</code>, <code>'b=string</code>, <code>'m=</code><a href="Ast/Size/index.html#type-t"><code>Ast.Size.t</code></a>. Corresponding aliases of the various instanciation with those type are types prefixed by <code>r</code> like <a href="Ast/index.html#type-rexp"><code>Ast.rexp</code></a>, <a href="Ast/index.html#type-rsmt"><code>Ast.rsmt</code></a>, <a href="Ast/index.html#type-rty"><code>Ast.rty</code></a>, and <a href="Ast/index.html#type-rsmt_ans"><code>Ast.rsmt_ans</code></a>.</p><p>The pretty-printer functions are a bit more tolerant in which type are allowed, but there still are some restrictions. Thus one may need to use some of the conversion function in next section before pretty-printing or after parsing.</p><h2 id="operations-on-expressions"><a href="#operations-on-expressions" class="anchor"></a>Operations on expressions</h2><p>Basic operation on expression like mapping/iterating over sub-expresions or variables is provided in <a href="Ast/Manip/index.html"><code>Ast.Manip</code></a>. This module also provide conversion of type parameters (like changing the type of variables).</p><p>Internally, typed expression are used, which mean that the <code>'a</code> parameter of the expressions is actually their type of ocaml type <a href="Ast/index.html#type-ty"><code>Ast.ty</code></a>. The <a href="Exp/Typed/index.html"><code>Exp.Typed</code></a> module provide smart constructors that allow to construct directly typed expressions. It also provide function to convert untyped expression to typed expressions. On top of that the <a href="Exp/index.html"><code>Exp</code></a> module provides a functor to apply over a variable functor that allow to lift variable behavior like equality and pretty printing at the expression level.</p><p><a href="Ast/Manip/index.html"><code>Ast.Manip</code></a> only provide syntactic operation on expression, other modules provide semantic operations on expressions:</p><ul><li><a href="Exp/Sums/index.html"><code>Exp.Sums</code></a> provide sum manipulation: allow to split and rebuild sum expression to/from list of terms.</li><li><a href="Exp/ConcreteEval/index.html"><code>Exp.ConcreteEval</code></a> provides concrete evaluation of expressions. It returns values of type <a href="Exp__/Value/index.html#type-t"><code>Exp.Value.t</code></a> which represent the possible concrete values that can result of an expression evaluation.</li><li><a href="Exp/PpExp/index.html"><code>Exp.PpExp</code></a> provide a more human readable expression printing than SMT-LIB syntax. Most operator are infix and have &quot;usual&quot; precedence. This module try to stay injective which means that a given pretty printed text represent a single possible syntactic expression.</li><li>And last but not least: <a href="Z3/index.html"><code>Z3</code></a> module allow interacting with Z3 for simplifying expression and checking SMT properties. If you use the high-level API of this module, you will not have to care about types like <a href="Ast/index.html#type-smt"><code>Ast.smt</code></a> or <a href="Ast/index.html#type-smt_ans"><code>Ast.smt_ans</code></a>.</li></ul><h2 id="symbolic-regions-of-memory"><a href="#symbolic-regions-of-memory" class="anchor"></a>Symbolic regions of memory</h2><p>In symbolic execution, one may need to represent large regions of memory in a symbolic manner. It would be possible to do that with a single expression of bitvector type with a very large size but this quickly become unwieldy. Furthermore in some case the machine code will perform writes at symbolic address which the position at which something is written in something else is symbolic. To represent this we use a two stage abstraction.</p><p>First, there is <a href="State/SymbolicBytes/index.html"><code>State.SymbolicBytes</code></a> which represent a block of memory which can contain arbitrary symbolic expressions at arbitrary but concrete addresses. Then <span class="xref-unresolved" title="unresolved reference to &quot;State.SymbolicFragment&quot;"><a href="State/index.html"><code>State</code></a>.SymbolicFragment</span> takes it one step further and provide a way to store arbitrary symbolic expressions at arbitrary symbolic addresses. When reading from a <span class="xref-unresolved" title="unresolved reference to &quot;State.SymbolicFragment&quot;"><a href="State/index.html"><code>State</code></a>.SymbolicFragment</span>, the read may not be resolved because of unknown aliasing of symbolic addresses. Those abstractions are only suitable to represent a sequential view of the memory without any concept of concurrent memory accesses.</p></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SymbolicExpressions (read-dwarf.SymbolicExpressions)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; SymbolicExpressions</nav><header class="odoc-preamble"><h1 id="symbolic-expressions"><a href="#symbolic-expressions" class="anchor"></a>Symbolic Expressions</h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#expression-representation-and-parametric-types">Expression representation and parametric types</a><ul><li><a href="#build-process-and-modules">Build process and modules</a></li><li><a href="#typopt">Expression type parameter and options</a></li></ul></li><li><a href="#operations-on-expressions">Operations on expressions</a></li><li><a href="#symbolic-regions-of-memory">Symbolic regions of memory</a></li></ul></nav></div><div class="odoc-content"><h2 id="expression-representation-and-parametric-types"><a href="#expression-representation-and-parametric-types" class="anchor"></a>Expression representation and parametric types</h2><p>The internal expression syntax is derived from <a href="http://smtlib.cs.uiowa.edu/">SMT-LIB</a> with the bitvector, boolean, and enumeration theory. The enumeration theory is about types that contain a specific number of numbered item. All the symbolic execution system is based of those expressions.</p><p>Optionally, an expression can support the whole memory through the SMT array theory from addresses to bytes or words. This support is optional, see <a href="#typopt" title="typopt">Expression type parameter and options</a></p><p>If you only wish to use those expression, I recommend you directly use the <a href="Ast/index.html"><code>Ast</code></a> module. This module export <a href="Ast/index.html#type-exp"><code>Ast.exp</code></a> as well as parsing and pretty printing capabilities.</p><p>The <a href="Ast/index.html"><code>Ast</code></a> module also define the syntax for SMT-LIB commands (<a href="Ast/index.html#type-smt"><code>Ast.smt</code></a>), and answers (<a href="Ast/index.html#type-smt_ans"><code>Ast.smt_ans</code></a>).</p><h3 id="build-process-and-modules"><a href="#build-process-and-modules" class="anchor"></a>Build process and modules</h3><p>The expressions types are build by <code>ott</code>. Currently, to avoid repetition, part of the <code>ott</code> AST comes from <code>isla_lang.ott</code> and only the difference with <code>isla-lang</code> are coming from the main <code>ast.ott</code> file. Only specific parts of <code>isla_lang.ott</code> are extracted with <code>extract_section.awk</code> before merging with <code>ast.ott</code>. The result of the call to <code>ott</code> are:</p><ul><li><a href="AstGen/Ott/index.html"><code>AstGen.Ott</code></a> that defined the ast types</li><li><a href="AstGen/Parser/index.html"><code>AstGen.Parser</code></a> The menhir parser module</li><li><a href="AstGen/Parser_pp/index.html"><code>AstGen.Parser_pp</code></a> The pprint pretty-printing module</li><li><a href="AstGen/Lexer/index.html"><code>AstGen.Lexer</code></a> The ocamllex lexer module</li></ul><p>One thing to be aware of is the dependency chain: first <a href="AstGen/Ott/index.html"><code>AstGen.Ott</code></a> is defined, then <a href="AstGen/Def/index.html"><code>AstGen.Def</code></a> (which is not generated) defines dome extra type definition to be used, then all the parsing and pretty printing module depend on <a href="AstGen/Def/index.html"><code>AstGen.Def</code></a> and then <a href="Ast/index.html"><code>Ast</code></a> encapsulates all of that for the rest of the codebase.</p><p>Unless you are tweaking things inside the AST, you should only use the <a href="Ast/index.html"><code>Ast</code></a> module.</p><h3 id="typopt"><a href="#typopt" class="anchor"></a>Expression type parameter and options</h3><p>The type of expression (<a href="Ast/index.html#type-exp"><code>Ast.exp</code></a>) is parametric and has currently 4 parameters that are propagated to other <a href="Ast/index.html"><code>Ast</code></a> types. Some <a href="Ast/index.html"><code>Ast</code></a> types only have a subset of those parameters when it make sense. It would be good to respect the variable letter names throughout the codebase to keep it consistent and understandable.</p><ul><li><code>'a</code>: Annotation type: The annotation is present on every expression constructor, and can be extracted with <code>Ast.Manip.annot</code></li><li><code>'v</code>: Variable type: The type of symbolic variables.</li><li><code>'b</code>: Bound variable type: The expression can optionally contain let bindings and bound variables with the usual semantics. This feature of expression can be disabled by putting <a href="Ast/index.html#type-no"><code>Ast.no</code></a> in that parameter slot, in which case all let-bindings constructors and bound variable (<code>Let</code> and <code>Bound</code>) are disabled.</li><li><code>'m</code>: Memory operation: This is intended to be a boolean option: only <a href="Ast/Base/Size/index.html#type-t"><code>Ast.Size.t</code></a> or <a href="Ast/index.html#type-no"><code>Ast.no</code></a>. In the first case, expression are allowed to contain memory array type and contain constructors like memory select or store. In the second case, all those operations are disabled and it is known that an expression can only be a bitvector, a boolean or an enumeration. In particular the content of register should generally not contain memory-enabled expressions.</li></ul><p>Expression coming out of the parser have their type parameter fixed to <code>'a=</code><a href="Ast/index.html#type-lrng"><code>Ast.lrng</code></a>, <code>'v=string</code>, <code>'b=string</code>, <code>'m=</code><a href="Ast/Base/Size/index.html#type-t"><code>Ast.Size.t</code></a>. Corresponding aliases of the various instanciation with those type are types prefixed by <code>r</code> like <a href="Ast/index.html#type-rexp"><code>Ast.rexp</code></a>, <a href="Ast/index.html#type-rsmt"><code>Ast.rsmt</code></a>, <a href="Ast/index.html#type-rty"><code>Ast.rty</code></a>, and <a href="Ast/index.html#type-rsmt_ans"><code>Ast.rsmt_ans</code></a>.</p><p>The pretty-printer functions are a bit more tolerant in which type are allowed, but there still are some restrictions. Thus one may need to use some of the conversion function in next section before pretty-printing or after parsing.</p><h2 id="operations-on-expressions"><a href="#operations-on-expressions" class="anchor"></a>Operations on expressions</h2><p>Basic operation on expression like mapping/iterating over sub-expresions or variables is provided in <a href="Ast/Manip/index.html"><code>Ast.Manip</code></a>. This module also provide conversion of type parameters (like changing the type of variables).</p><p>Internally, typed expression are used, which mean that the <code>'a</code> parameter of the expressions is actually their type of ocaml type <a href="Ast/index.html#type-ty"><code>Ast.ty</code></a>. The <a href="Exp/Typed/index.html"><code>Exp.Typed</code></a> module provide smart constructors that allow to construct directly typed expressions. It also provide function to convert untyped expression to typed expressions. On top of that the <a href="Exp/index.html"><code>Exp</code></a> module provides a functor to apply over a variable functor that allow to lift variable behavior like equality and pretty printing at the expression level.</p><p><a href="Ast/Manip/index.html"><code>Ast.Manip</code></a> only provide syntactic operation on expression, other modules provide semantic operations on expressions:</p><ul><li><a href="Exp/Sums/index.html"><code>Exp.Sums</code></a> provide sum manipulation: allow to split and rebuild sum expression to/from list of terms.</li><li><a href="Exp/ConcreteEval/index.html"><code>Exp.ConcreteEval</code></a> provides concrete evaluation of expressions. It returns values of type <a href="Exp/Value/index.html#type-t"><code>Exp.Value.t</code></a> which represent the possible concrete values that can result of an expression evaluation.</li><li><a href="Exp/PpExp/index.html"><code>Exp.PpExp</code></a> provide a more human readable expression printing than SMT-LIB syntax. Most operator are infix and have &quot;usual&quot; precedence. This module try to stay injective which means that a given pretty printed text represent a single possible syntactic expression.</li><li>And last but not least: <a href="Z3/index.html"><code>Z3</code></a> module allow interacting with Z3 for simplifying expression and checking SMT properties. If you use the high-level API of this module, you will not have to care about types like <a href="Ast/index.html#type-smt"><code>Ast.smt</code></a> or <a href="Ast/index.html#type-smt_ans"><code>Ast.smt_ans</code></a>.</li></ul><h2 id="symbolic-regions-of-memory"><a href="#symbolic-regions-of-memory" class="anchor"></a>Symbolic regions of memory</h2><p>In symbolic execution, one may need to represent large regions of memory in a symbolic manner. It would be possible to do that with a single expression of bitvector type with a very large size but this quickly become unwieldy. Furthermore in some case the machine code will perform writes at symbolic address which the position at which something is written in something else is symbolic. To represent this we use a two stage abstraction.</p><p>First, there is <a href="State/SymbolicBytes/index.html"><code>State.SymbolicBytes</code></a> which represent a block of memory which can contain arbitrary symbolic expressions at arbitrary but concrete addresses. Then <code>State.SymbolicFragment</code> takes it one step further and provide a way to store arbitrary symbolic expressions at arbitrary symbolic addresses. When reading from a <code>State.SymbolicFragment</code>, the read may not be resolved because of unknown aliasing of symbolic addresses. Those abstractions are only suitable to represent a sequential view of the memory without any concept of concurrent memory accesses.</p></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/BytesSeqT/index.html b/doc/html/read-dwarf/Tests/BytesSeqT/index.html
index ca788531..9eec7958 100644
--- a/doc/html/read-dwarf/Tests/BytesSeqT/index.html
+++ b/doc/html/read-dwarf/Tests/BytesSeqT/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BytesSeqT (read-dwarf.Tests.BytesSeqT)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; BytesSeqT</nav><h1>Module <code>Tests.BytesSeqT</code></h1></header><dl><dt class="spec value" id="val-has_even_len"><a href="#val-has_even_len" class="anchor"></a><code><span class="keyword">val</span> has_even_len : string <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hex_digit"><a href="#val-hex_digit" class="anchor"></a><code><span class="keyword">val</span> hex_digit : <span>char <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.arbitrary</span></code></dt><dt class="spec value" id="val-hex_string"><a href="#val-hex_string" class="anchor"></a><code><span class="keyword">val</span> hex_string : <span>string <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.arbitrary</span></code></dt><dt class="spec value" id="val-is_hex"><a href="#val-is_hex" class="anchor"></a><code><span class="keyword">val</span> is_hex : char <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-well_formed"><a href="#val-well_formed" class="anchor"></a><code><span class="keyword">val</span> well_formed : <a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t</code></dt><dt class="spec value" id="val-odd_len"><a href="#val-odd_len" class="anchor"></a><code><span class="keyword">val</span> odd_len : <a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t</code></dt><dt class="spec value" id="val-not_hex"><a href="#val-not_hex" class="anchor"></a><code><span class="keyword">val</span> not_hex : <a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t</code></dt><dt class="spec value" id="val-tests"><a href="#val-tests" class="anchor"></a><code><span class="keyword">val</span> tests : <span><a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t list</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BytesSeqT (read-dwarf.Tests.BytesSeqT)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; BytesSeqT</nav><header class="odoc-preamble"><h1>Module <code><span>Tests.BytesSeqT</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-has_even_len"><a href="#val-has_even_len" class="anchor"></a><code><span><span class="keyword">val</span> has_even_len : <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex_digit"><a href="#val-hex_digit" class="anchor"></a><code><span><span class="keyword">val</span> hex_digit : <span>char <span class="xref-unresolved">Tests</span>.Common.Q.arbitrary</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex_string"><a href="#val-hex_string" class="anchor"></a><code><span><span class="keyword">val</span> hex_string : <span>string <span class="xref-unresolved">Tests</span>.Common.Q.arbitrary</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_hex"><a href="#val-is_hex" class="anchor"></a><code><span><span class="keyword">val</span> is_hex : <span>char <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-well_formed"><a href="#val-well_formed" class="anchor"></a><code><span><span class="keyword">val</span> well_formed : <span class="xref-unresolved">Tests</span>.Common.QCT.t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-odd_len"><a href="#val-odd_len" class="anchor"></a><code><span><span class="keyword">val</span> odd_len : <span class="xref-unresolved">Tests</span>.Common.QCT.t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not_hex"><a href="#val-not_hex" class="anchor"></a><code><span><span class="keyword">val</span> not_hex : <span class="xref-unresolved">Tests</span>.Common.QCT.t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tests"><a href="#val-tests" class="anchor"></a><code><span><span class="keyword">val</span> tests : <span><span class="xref-unresolved">Tests</span>.Common.QCT.t list</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/Common/Gen/index.html b/doc/html/read-dwarf/Tests/Common/Gen/index.html
index 991efcd9..e8948681 100644
--- a/doc/html/read-dwarf/Tests/Common/Gen/index.html
+++ b/doc/html/read-dwarf/Tests/Common/Gen/index.html
@@ -1,2 +1,43 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Gen (read-dwarf.Tests.Common.Gen)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">Common</a> &#x00BB; Gen</nav><h1>Module <code>Common.Gen</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../index.html#module-Q">Q</a>.Gen</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = Stdlib.Random.State.t <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec type" id="type-sized"><a href="#type-sized" class="anchor"></a><code><span class="keyword">type</span> <span>'a sized</span></code><code> = int <span>&#45;&gt;</span> Stdlib.Random.State.t <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec value" id="val-return"><a href="#val-return" class="anchor"></a><code><span class="keyword">val</span> return : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-pure"><a href="#val-pure" class="anchor"></a><code><span class="keyword">val</span> pure : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(&gt;&gt;=)"><a href="#val-(&gt;&gt;=)" class="anchor"></a><code><span class="keyword">val</span> (&gt;&gt;=) : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(&lt;*&gt;)"><a href="#val-(&lt;*&gt;)" class="anchor"></a><code><span class="keyword">val</span> (&lt;*&gt;) : <span><span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span class="keyword">val</span> map2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-map3"><a href="#val-map3" class="anchor"></a><code><span class="keyword">val</span> map3 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> <span>&#45;&gt;</span> <span class="type-var">'d</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'d</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-map_keep_input"><a href="#val-map_keep_input" class="anchor"></a><code><span class="keyword">val</span> map_keep_input : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(&gt;|=)"><a href="#val-(&gt;|=)" class="anchor"></a><code><span class="keyword">val</span> (&gt;|=) : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(&lt;$&gt;)"><a href="#val-(&lt;$&gt;)" class="anchor"></a><code><span class="keyword">val</span> (&lt;$&gt;) : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-oneof"><a href="#val-oneof" class="anchor"></a><code><span class="keyword">val</span> oneof : <span><span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-oneofl"><a href="#val-oneofl" class="anchor"></a><code><span class="keyword">val</span> oneofl : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-oneofa"><a href="#val-oneofa" class="anchor"></a><code><span class="keyword">val</span> oneofa : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-frequency"><a href="#val-frequency" class="anchor"></a><code><span class="keyword">val</span> frequency : <span><span>(int * <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span>)</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-frequencyl"><a href="#val-frequencyl" class="anchor"></a><code><span class="keyword">val</span> frequencyl : <span><span>(int * <span class="type-var">'a</span>)</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-frequencya"><a href="#val-frequencya" class="anchor"></a><code><span class="keyword">val</span> frequencya : <span><span>(int * <span class="type-var">'a</span>)</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-shuffle_a"><a href="#val-shuffle_a" class="anchor"></a><code><span class="keyword">val</span> shuffle_a : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-shuffle_l"><a href="#val-shuffle_l" class="anchor"></a><code><span class="keyword">val</span> shuffle_l : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-shuffle_w_l"><a href="#val-shuffle_w_l" class="anchor"></a><code><span class="keyword">val</span> shuffle_w_l : <span><span>(int * <span class="type-var">'a</span>)</span> list</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-unit"><a href="#val-unit" class="anchor"></a><code><span class="keyword">val</span> unit : <span>unit <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span class="keyword">val</span> bool : <span>bool <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-float"><a href="#val-float" class="anchor"></a><code><span class="keyword">val</span> float : <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-pfloat"><a href="#val-pfloat" class="anchor"></a><code><span class="keyword">val</span> pfloat : <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-nfloat"><a href="#val-nfloat" class="anchor"></a><code><span class="keyword">val</span> nfloat : <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-float_bound_inclusive"><a href="#val-float_bound_inclusive" class="anchor"></a><code><span class="keyword">val</span> float_bound_inclusive : float <span>&#45;&gt;</span> <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-float_bound_exclusive"><a href="#val-float_bound_exclusive" class="anchor"></a><code><span class="keyword">val</span> float_bound_exclusive : float <span>&#45;&gt;</span> <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-float_range"><a href="#val-float_range" class="anchor"></a><code><span class="keyword">val</span> float_range : float <span>&#45;&gt;</span> float <span>&#45;&gt;</span> <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-(--.)"><a href="#val-(--.)" class="anchor"></a><code><span class="keyword">val</span> (--.) : float <span>&#45;&gt;</span> float <span>&#45;&gt;</span> <span>float <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-nat"><a href="#val-nat" class="anchor"></a><code><span class="keyword">val</span> nat : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-big_nat"><a href="#val-big_nat" class="anchor"></a><code><span class="keyword">val</span> big_nat : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-neg_int"><a href="#val-neg_int" class="anchor"></a><code><span class="keyword">val</span> neg_int : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-pint"><a href="#val-pint" class="anchor"></a><code><span class="keyword">val</span> pint : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-int"><a href="#val-int" class="anchor"></a><code><span class="keyword">val</span> int : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-small_nat"><a href="#val-small_nat" class="anchor"></a><code><span class="keyword">val</span> small_nat : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-small_int"><a href="#val-small_int" class="anchor"></a><code><span class="keyword">val</span> small_int : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-small_signed_int"><a href="#val-small_signed_int" class="anchor"></a><code><span class="keyword">val</span> small_signed_int : <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-int_bound"><a href="#val-int_bound" class="anchor"></a><code><span class="keyword">val</span> int_bound : int <span>&#45;&gt;</span> <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-int_range"><a href="#val-int_range" class="anchor"></a><code><span class="keyword">val</span> int_range : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-graft_corners"><a href="#val-graft_corners" class="anchor"></a><code><span class="keyword">val</span> graft_corners : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-int_pos_corners"><a href="#val-int_pos_corners" class="anchor"></a><code><span class="keyword">val</span> int_pos_corners : <span>int list</span></code></dt><dt class="spec value" id="val-int_corners"><a href="#val-int_corners" class="anchor"></a><code><span class="keyword">val</span> int_corners : <span>int list</span></code></dt><dt class="spec value" id="val-(--)"><a href="#val-(--)" class="anchor"></a><code><span class="keyword">val</span> (--) : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>int <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-ui32"><a href="#val-ui32" class="anchor"></a><code><span class="keyword">val</span> ui32 : <span>int32 <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-ui64"><a href="#val-ui64" class="anchor"></a><code><span class="keyword">val</span> ui64 : <span>int64 <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-list"><a href="#val-list" class="anchor"></a><code><span class="keyword">val</span> list : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-list_size"><a href="#val-list_size" class="anchor"></a><code><span class="keyword">val</span> list_size : <span>int <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-list_repeat"><a href="#val-list_repeat" class="anchor"></a><code><span class="keyword">val</span> list_repeat : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-array"><a href="#val-array" class="anchor"></a><code><span class="keyword">val</span> array : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-array_size"><a href="#val-array_size" class="anchor"></a><code><span class="keyword">val</span> array_size : <span>int <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-array_repeat"><a href="#val-array_repeat" class="anchor"></a><code><span class="keyword">val</span> array_repeat : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-opt"><a href="#val-opt" class="anchor"></a><code><span class="keyword">val</span> opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> option</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-pair"><a href="#val-pair" class="anchor"></a><code><span class="keyword">val</span> pair : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-triple"><a href="#val-triple" class="anchor"></a><code><span class="keyword">val</span> triple : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-quad"><a href="#val-quad" class="anchor"></a><code><span class="keyword">val</span> quad : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'d</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-char"><a href="#val-char" class="anchor"></a><code><span class="keyword">val</span> char : <span>char <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-printable"><a href="#val-printable" class="anchor"></a><code><span class="keyword">val</span> printable : <span>char <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-numeral"><a href="#val-numeral" class="anchor"></a><code><span class="keyword">val</span> numeral : <span>char <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-char_range"><a href="#val-char_range" class="anchor"></a><code><span class="keyword">val</span> char_range : char <span>&#45;&gt;</span> char <span>&#45;&gt;</span> <span>char <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-string_size"><a href="#val-string_size" class="anchor"></a><code><span class="keyword">val</span> string_size : <span>?&#8288;gen:<span>char <a href="index.html#type-t">t</a></span></span> <span>&#45;&gt;</span> <span>int <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>string <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-string"><a href="#val-string" class="anchor"></a><code><span class="keyword">val</span> string : <span>?&#8288;gen:<span>char <a href="index.html#type-t">t</a></span></span> <span>&#45;&gt;</span> <span>string <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-string_of"><a href="#val-string_of" class="anchor"></a><code><span class="keyword">val</span> string_of : <span>char <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>string <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-string_readable"><a href="#val-string_readable" class="anchor"></a><code><span class="keyword">val</span> string_readable : <span>string <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-small_string"><a href="#val-small_string" class="anchor"></a><code><span class="keyword">val</span> small_string : <span>?&#8288;gen:<span>char <a href="index.html#type-t">t</a></span></span> <span>&#45;&gt;</span> <span>string <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-small_list"><a href="#val-small_list" class="anchor"></a><code><span class="keyword">val</span> small_list : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-flatten_l"><a href="#val-flatten_l" class="anchor"></a><code><span class="keyword">val</span> flatten_l : <span><span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> list</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-flatten_a"><a href="#val-flatten_a" class="anchor"></a><code><span class="keyword">val</span> flatten_a : <span><span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> array</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-flatten_opt"><a href="#val-flatten_opt" class="anchor"></a><code><span class="keyword">val</span> flatten_opt : <span><span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> option</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> option</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-flatten_res"><a href="#val-flatten_res" class="anchor"></a><code><span class="keyword">val</span> flatten_res : <span><span>(<span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span>, <span class="type-var">'e</span>)</span> Stdlib.result</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'e</span>)</span> Stdlib.result</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-small_array"><a href="#val-small_array" class="anchor"></a><code><span class="keyword">val</span> small_array : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-join"><a href="#val-join" class="anchor"></a><code><span class="keyword">val</span> join : <span><span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-sized"><a href="#val-sized" class="anchor"></a><code><span class="keyword">val</span> sized : <span><span class="type-var">'a</span> <a href="index.html#type-sized">sized</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-sized_size"><a href="#val-sized_size" class="anchor"></a><code><span class="keyword">val</span> sized_size : <span>int <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-sized">sized</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-fix"><a href="#val-fix" class="anchor"></a><code><span class="keyword">val</span> fix : <span>(<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-generate"><a href="#val-generate" class="anchor"></a><code><span class="keyword">val</span> generate : <span>?&#8288;rand:Stdlib.Random.State.t</span> <span>&#45;&gt;</span> <span>n:int</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-generate1"><a href="#val-generate1" class="anchor"></a><code><span class="keyword">val</span> generate1 : <span>?&#8288;rand:Stdlib.Random.State.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-let+"><a href="#val-let+" class="anchor"></a><code><span class="keyword">val</span> let+ : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-and+"><a href="#val-and+" class="anchor"></a><code><span class="keyword">val</span> and+ : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-let*"><a href="#val-let*" class="anchor"></a><code><span class="keyword">val</span> let* : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-and*"><a href="#val-and*" class="anchor"></a><code><span class="keyword">val</span> and* : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Gen (read-dwarf.Tests.Common.Gen)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">Common</a> &#x00BB; Gen</nav><header class="odoc-preamble"><h1>Module <code><span>Common.Gen</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Q</span>.Gen <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="xref-unresolved">Stdlib</span>.Random.State.t <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-sized"><a href="#type-sized" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a sized</span></span><span> = <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.Random.State.t <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-return"><a href="#val-return" class="anchor"></a><code><span><span class="keyword">val</span> return : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pure"><a href="#val-pure" class="anchor"></a><code><span><span class="keyword">val</span> pure : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(&gt;&gt;=)"><a href="#val-(&gt;&gt;=)" class="anchor"></a><code><span><span class="keyword">val</span> (&gt;&gt;=) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(&lt;*&gt;)"><a href="#val-(&lt;*&gt;)" class="anchor"></a><code><span><span class="keyword">val</span> (&lt;*&gt;) : <span><span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map3"><a href="#val-map3" class="anchor"></a><code><span><span class="keyword">val</span> map3 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'d</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'d</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map4"><a href="#val-map4" class="anchor"></a><code><span><span class="keyword">val</span> map4 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'d</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'e</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'e</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map5"><a href="#val-map5" class="anchor"></a><code><span><span class="keyword">val</span> map5 : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'d</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'e</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'f</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'f</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_keep_input"><a href="#val-map_keep_input" class="anchor"></a><code><span><span class="keyword">val</span> map_keep_input : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(&gt;|=)"><a href="#val-(&gt;|=)" class="anchor"></a><code><span><span class="keyword">val</span> (&gt;|=) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(&lt;$&gt;)"><a href="#val-(&lt;$&gt;)" class="anchor"></a><code><span><span class="keyword">val</span> (&lt;$&gt;) : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-oneof"><a href="#val-oneof" class="anchor"></a><code><span><span class="keyword">val</span> oneof : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-oneofl"><a href="#val-oneofl" class="anchor"></a><code><span><span class="keyword">val</span> oneofl : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-oneofa"><a href="#val-oneofa" class="anchor"></a><code><span><span class="keyword">val</span> oneofa : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-frequency"><a href="#val-frequency" class="anchor"></a><code><span><span class="keyword">val</span> frequency : <span><span><span>(int * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-frequencyl"><a href="#val-frequencyl" class="anchor"></a><code><span><span class="keyword">val</span> frequencyl : <span><span><span>(int * <span class="type-var">'a</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-frequencya"><a href="#val-frequencya" class="anchor"></a><code><span><span class="keyword">val</span> frequencya : <span><span><span>(int * <span class="type-var">'a</span>)</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shuffle_a"><a href="#val-shuffle_a" class="anchor"></a><code><span><span class="keyword">val</span> shuffle_a : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>unit <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shuffle_l"><a href="#val-shuffle_l" class="anchor"></a><code><span><span class="keyword">val</span> shuffle_l : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shuffle_w_l"><a href="#val-shuffle_w_l" class="anchor"></a><code><span><span class="keyword">val</span> shuffle_w_l : <span><span><span>(int * <span class="type-var">'a</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-range_subset"><a href="#val-range_subset" class="anchor"></a><code><span><span class="keyword">val</span> range_subset : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>int array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-array_subset"><a href="#val-array_subset" class="anchor"></a><code><span><span class="keyword">val</span> array_subset : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unit"><a href="#val-unit" class="anchor"></a><code><span><span class="keyword">val</span> unit : <span>unit <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span><span class="keyword">val</span> bool : <span>bool <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-float"><a href="#val-float" class="anchor"></a><code><span><span class="keyword">val</span> float : <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pfloat"><a href="#val-pfloat" class="anchor"></a><code><span><span class="keyword">val</span> pfloat : <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nfloat"><a href="#val-nfloat" class="anchor"></a><code><span><span class="keyword">val</span> nfloat : <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-float_bound_inclusive"><a href="#val-float_bound_inclusive" class="anchor"></a><code><span><span class="keyword">val</span> float_bound_inclusive : <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-float_bound_exclusive"><a href="#val-float_bound_exclusive" class="anchor"></a><code><span><span class="keyword">val</span> float_bound_exclusive : <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-float_range"><a href="#val-float_range" class="anchor"></a><code><span><span class="keyword">val</span> float_range : <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(--.)"><a href="#val-(--.)" class="anchor"></a><code><span><span class="keyword">val</span> (--.) : <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exponential"><a href="#val-exponential" class="anchor"></a><code><span><span class="keyword">val</span> exponential : <span>float <span class="arrow">&#45;&gt;</span></span> <span>float <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nat"><a href="#val-nat" class="anchor"></a><code><span><span class="keyword">val</span> nat : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-big_nat"><a href="#val-big_nat" class="anchor"></a><code><span><span class="keyword">val</span> big_nat : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-neg_int"><a href="#val-neg_int" class="anchor"></a><code><span><span class="keyword">val</span> neg_int : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pint"><a href="#val-pint" class="anchor"></a><code><span><span class="keyword">val</span> pint : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int"><a href="#val-int" class="anchor"></a><code><span><span class="keyword">val</span> int : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_nat"><a href="#val-small_nat" class="anchor"></a><code><span><span class="keyword">val</span> small_nat : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_int"><a href="#val-small_int" class="anchor"></a><code><span><span class="keyword">val</span> small_int : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_signed_int"><a href="#val-small_signed_int" class="anchor"></a><code><span><span class="keyword">val</span> small_signed_int : <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int_bound"><a href="#val-int_bound" class="anchor"></a><code><span><span class="keyword">val</span> int_bound : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int_range"><a href="#val-int_range" class="anchor"></a><code><span><span class="keyword">val</span> int_range : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-graft_corners"><a href="#val-graft_corners" class="anchor"></a><code><span><span class="keyword">val</span> graft_corners : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int_pos_corners"><a href="#val-int_pos_corners" class="anchor"></a><code><span><span class="keyword">val</span> int_pos_corners : <span>int list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int_corners"><a href="#val-int_corners" class="anchor"></a><code><span><span class="keyword">val</span> int_corners : <span>int list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(--)"><a href="#val-(--)" class="anchor"></a><code><span><span class="keyword">val</span> (--) : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int32"><a href="#val-int32" class="anchor"></a><code><span><span class="keyword">val</span> int32 : <span>int32 <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int64"><a href="#val-int64" class="anchor"></a><code><span><span class="keyword">val</span> int64 : <span>int64 <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ui32"><a href="#val-ui32" class="anchor"></a><code><span><span class="keyword">val</span> ui32 : <span>int32 <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ui64"><a href="#val-ui64" class="anchor"></a><code><span><span class="keyword">val</span> ui64 : <span>int64 <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-list"><a href="#val-list" class="anchor"></a><code><span><span class="keyword">val</span> list : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-list_size"><a href="#val-list_size" class="anchor"></a><code><span><span class="keyword">val</span> list_size : <span><span>int <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-list_repeat"><a href="#val-list_repeat" class="anchor"></a><code><span><span class="keyword">val</span> list_repeat : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-array"><a href="#val-array" class="anchor"></a><code><span><span class="keyword">val</span> array : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-array_size"><a href="#val-array_size" class="anchor"></a><code><span><span class="keyword">val</span> array_size : <span><span>int <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-array_repeat"><a href="#val-array_repeat" class="anchor"></a><code><span><span class="keyword">val</span> array_repeat : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-option"><a href="#val-option" class="anchor"></a><code><span><span class="keyword">val</span> option : <span><span class="optlabel">?ratio</span>:float <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-opt"><a href="#val-opt" class="anchor"></a><code><span><span class="keyword">val</span> opt : <span><span class="optlabel">?ratio</span>:float <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-result"><a href="#val-result" class="anchor"></a><code><span><span class="keyword">val</span> result : <span><span class="optlabel">?ratio</span>:float <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'e</span>)</span> <span class="xref-unresolved">Stdlib</span>.result</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-char"><a href="#val-char" class="anchor"></a><code><span><span class="keyword">val</span> char : <span>char <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-printable"><a href="#val-printable" class="anchor"></a><code><span><span class="keyword">val</span> printable : <span>char <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-numeral"><a href="#val-numeral" class="anchor"></a><code><span><span class="keyword">val</span> numeral : <span>char <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-char_range"><a href="#val-char_range" class="anchor"></a><code><span><span class="keyword">val</span> char_range : <span>char <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span>char <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_size"><a href="#val-bytes_size" class="anchor"></a><code><span><span class="keyword">val</span> bytes_size : <span><span class="optlabel">?gen</span>:<span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>int <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>bytes <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes"><a href="#val-bytes" class="anchor"></a><code><span><span class="keyword">val</span> bytes : <span><span class="optlabel">?gen</span>:<span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>bytes <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_of"><a href="#val-bytes_of" class="anchor"></a><code><span><span class="keyword">val</span> bytes_of : <span><span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>bytes <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_printable"><a href="#val-bytes_printable" class="anchor"></a><code><span><span class="keyword">val</span> bytes_printable : <span>bytes <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_small"><a href="#val-bytes_small" class="anchor"></a><code><span><span class="keyword">val</span> bytes_small : <span>bytes <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_small_of"><a href="#val-bytes_small_of" class="anchor"></a><code><span><span class="keyword">val</span> bytes_small_of : <span><span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>bytes <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_size"><a href="#val-string_size" class="anchor"></a><code><span><span class="keyword">val</span> string_size : <span><span class="optlabel">?gen</span>:<span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>int <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string"><a href="#val-string" class="anchor"></a><code><span><span class="keyword">val</span> string : <span><span class="optlabel">?gen</span>:<span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_of"><a href="#val-string_of" class="anchor"></a><code><span><span class="keyword">val</span> string_of : <span><span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_readable"><a href="#val-string_readable" class="anchor"></a><code><span><span class="keyword">val</span> string_readable : <span>string <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><ul class="at-tags"><li class="deprecated"><span class="at-tag">deprecated</span> see string_printable</li></ul></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_printable"><a href="#val-string_printable" class="anchor"></a><code><span><span class="keyword">val</span> string_printable : <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_string"><a href="#val-small_string" class="anchor"></a><code><span><span class="keyword">val</span> small_string : <span><span class="optlabel">?gen</span>:<span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_small"><a href="#val-string_small" class="anchor"></a><code><span><span class="keyword">val</span> string_small : <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string_small_of"><a href="#val-string_small_of" class="anchor"></a><code><span><span class="keyword">val</span> string_small_of : <span><span>char <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_list"><a href="#val-small_list" class="anchor"></a><code><span><span class="keyword">val</span> small_list : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten_l"><a href="#val-flatten_l" class="anchor"></a><code><span><span class="keyword">val</span> flatten_l : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten_a"><a href="#val-flatten_a" class="anchor"></a><code><span><span class="keyword">val</span> flatten_a : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten_opt"><a href="#val-flatten_opt" class="anchor"></a><code><span><span class="keyword">val</span> flatten_opt : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten_res"><a href="#val-flatten_res" class="anchor"></a><code><span><span class="keyword">val</span> flatten_res : <span><span><span>(<span><span class="type-var">'a</span> <a href="#type-t">t</a></span>, <span class="type-var">'e</span>)</span> <span class="xref-unresolved">Stdlib</span>.result</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'e</span>)</span> <span class="xref-unresolved">Stdlib</span>.result</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-small_array"><a href="#val-small_array" class="anchor"></a><code><span><span class="keyword">val</span> small_array : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pair"><a href="#val-pair" class="anchor"></a><code><span><span class="keyword">val</span> pair : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-triple"><a href="#val-triple" class="anchor"></a><code><span><span class="keyword">val</span> triple : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-quad"><a href="#val-quad" class="anchor"></a><code><span><span class="keyword">val</span> quad : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup2"><a href="#val-tup2" class="anchor"></a><code><span><span class="keyword">val</span> tup2 : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup3"><a href="#val-tup3" class="anchor"></a><code><span><span class="keyword">val</span> tup3 : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup4"><a href="#val-tup4" class="anchor"></a><code><span><span class="keyword">val</span> tup4 : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup5"><a href="#val-tup5" class="anchor"></a><code><span><span class="keyword">val</span> tup5 : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span> * <span class="type-var">'e</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup6"><a href="#val-tup6" class="anchor"></a><code><span><span class="keyword">val</span> tup6 : 
+  <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'f</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span> * <span class="type-var">'e</span> * <span class="type-var">'f</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup7"><a href="#val-tup7" class="anchor"></a><code><span><span class="keyword">val</span> tup7 : 
+  <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'f</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'g</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span> * <span class="type-var">'e</span> * <span class="type-var">'f</span> * <span class="type-var">'g</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup8"><a href="#val-tup8" class="anchor"></a><code><span><span class="keyword">val</span> tup8 : 
+  <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'f</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'g</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'h</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span> * <span class="type-var">'e</span> * <span class="type-var">'f</span> * <span class="type-var">'g</span> * <span class="type-var">'h</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup9"><a href="#val-tup9" class="anchor"></a><code><span><span class="keyword">val</span> tup9 : 
+  <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'c</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'d</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'e</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'f</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'g</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'h</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'i</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span> * <span class="type-var">'d</span> * <span class="type-var">'e</span> * <span class="type-var">'f</span> * <span class="type-var">'g</span> * <span class="type-var">'h</span> * <span class="type-var">'i</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-join"><a href="#val-join" class="anchor"></a><code><span><span class="keyword">val</span> join : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sized"><a href="#val-sized" class="anchor"></a><code><span><span class="keyword">val</span> sized : <span><span><span class="type-var">'a</span> <a href="#type-sized">sized</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sized_size"><a href="#val-sized_size" class="anchor"></a><code><span><span class="keyword">val</span> sized_size : <span><span>int <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-sized">sized</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fix"><a href="#val-fix" class="anchor"></a><code><span><span class="keyword">val</span> fix : <span><span>(<span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nat_split2"><a href="#val-nat_split2" class="anchor"></a><code><span><span class="keyword">val</span> nat_split2 : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(int * int)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pos_split2"><a href="#val-pos_split2" class="anchor"></a><code><span><span class="keyword">val</span> pos_split2 : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(int * int)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nat_split"><a href="#val-nat_split" class="anchor"></a><code><span><span class="keyword">val</span> nat_split : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>int array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pos_split"><a href="#val-pos_split" class="anchor"></a><code><span><span class="keyword">val</span> pos_split : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>int array</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-delay"><a href="#val-delay" class="anchor"></a><code><span><span class="keyword">val</span> delay : <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-generate"><a href="#val-generate" class="anchor"></a><code><span><span class="keyword">val</span> generate : <span><span class="optlabel">?rand</span>:<span class="xref-unresolved">Stdlib</span>.Random.State.t <span class="arrow">&#45;&gt;</span></span> <span><span class="label">n</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-generate1"><a href="#val-generate1" class="anchor"></a><code><span><span class="keyword">val</span> generate1 : <span><span class="optlabel">?rand</span>:<span class="xref-unresolved">Stdlib</span>.Random.State.t <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let+)"><a href="#val-(let+)" class="anchor"></a><code><span><span class="keyword">val</span> (let+) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and+)"><a href="#val-(and+)" class="anchor"></a><code><span><span class="keyword">val</span> (and+) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let*)"><a href="#val-(let*)" class="anchor"></a><code><span><span class="keyword">val</span> (let*) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and*)"><a href="#val-(and*)" class="anchor"></a><code><span><span class="keyword">val</span> (and*) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/Common/index.html b/doc/html/read-dwarf/Tests/Common/index.html
index 5249c660..79333d8e 100644
--- a/doc/html/read-dwarf/Tests/Common/index.html
+++ b/doc/html/read-dwarf/Tests/Common/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Common (read-dwarf.Tests.Common)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; Common</nav><h1>Module <code>Tests.Common</code></h1></header><dl><dt class="spec module" id="module-Q"><a href="#module-Q" class="anchor"></a><code><span class="keyword">module</span> Q = QCheck</code></dt><dd><p>This module provide all the common testing infrastructure. It is intended to be opened in all testing modules</p></dd></dl><div class="spec module" id="module-Gen"><a href="#module-Gen" class="anchor"></a><code><span class="keyword">module</span> <a href="Gen/index.html">Gen</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-QCT"><a href="#module-QCT" class="anchor"></a><code><span class="keyword">module</span> QCT = <a href="index.html#module-Q">Q</a>.Test</code></div><div class="spec module" id="module-Print"><a href="#module-Print" class="anchor"></a><code><span class="keyword">module</span> Print = <a href="index.html#module-Q">Q</a>.Print</code></div><dl><dt class="spec value" id="val-(==&gt;)"><a href="#val-(==&gt;)" class="anchor"></a><code><span class="keyword">val</span> (==&gt;) : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Common (read-dwarf.Tests.Common)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; Common</nav><header class="odoc-preamble"><h1>Module <code><span>Tests.Common</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Q"><a href="#module-Q" class="anchor"></a><code><span><span class="keyword">module</span> Q</span><span> = <span class="xref-unresolved">QCheck</span></span></code></div><div class="spec-doc"><p>This module provide all the common testing infrastructure. It is intended to be opened in all testing modules</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Gen"><a href="#module-Gen" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Gen/index.html">Gen</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-QCT"><a href="#module-QCT" class="anchor"></a><code><span><span class="keyword">module</span> QCT</span><span> = <span class="xref-unresolved">Q</span>.Test</span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Print"><a href="#module-Print" class="anchor"></a><code><span><span class="keyword">module</span> Print</span><span> = <span class="xref-unresolved">Q</span>.Print</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(==&gt;)"><a href="#val-(==&gt;)" class="anchor"></a><code><span><span class="keyword">val</span> (==&gt;) : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ConcreteEvalT/index.html b/doc/html/read-dwarf/Tests/ConcreteEvalT/index.html
index ab1818b2..9127e659 100644
--- a/doc/html/read-dwarf/Tests/ConcreteEvalT/index.html
+++ b/doc/html/read-dwarf/Tests/ConcreteEvalT/index.html
@@ -1,2 +1,14 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ConcreteEvalT (read-dwarf.Tests.ConcreteEvalT)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; ConcreteEvalT</nav><h1>Module <code>Tests.ConcreteEvalT</code></h1></header><aside><p>This module is for testing <a href="ConcreteEval/index.html"><code>ConcreteEval</code></a></p></aside><div class="spec module" id="module-ConcreteEval"><a href="#module-ConcreteEval" class="anchor"></a><code><span class="keyword">module</span> ConcreteEval = <a href="../../Exp/index.html#module-ConcreteEval">Exp.ConcreteEval</a></code></div><div class="spec module" id="module-Value"><a href="#module-Value" class="anchor"></a><code><span class="keyword">module</span> Value = <a href="../../Exp/index.html#module-Value">Exp.Value</a></code></div><div class="spec module" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span class="keyword">module</span> Typed = <a href="../../Exp/index.html#module-Typed">Exp.Typed</a></code></div><dl><dt class="spec value" id="val-const_exp_gen_ty"><a href="#val-const_exp_gen_ty" class="anchor"></a><code><span class="keyword">val</span> const_exp_gen_ty : int <span>&#45;&gt;</span> <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-const_exp_gen"><a href="#val-const_exp_gen" class="anchor"></a><code><span class="keyword">val</span> const_exp_gen : int <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-const_exp_shrinker_top"><a href="#val-const_exp_shrinker_top" class="anchor"></a><code><span class="keyword">val</span> const_exp_shrinker_top : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span>&#45;&gt;</span> <span>(<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Shrink by trying all sub expressions</p></dd></dl><dl><dt class="spec value" id="val-const_exp_shrinker_bot"><a href="#val-const_exp_shrinker_bot" class="anchor"></a><code><span class="keyword">val</span> const_exp_shrinker_bot : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <span>(<span><span>(<span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Shrink by replacing a non-atomic constant expression by it's constEval evaluation</p></dd></dl><dl><dt class="spec value" id="val-const_exp_shrinker"><a href="#val-const_exp_shrinker" class="anchor"></a><code><span class="keyword">val</span> const_exp_shrinker : <span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span>&#45;&gt;</span> <span>(<span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Shrink by using both <a href="index.html#val-const_exp_shrinker_top"><code>const_exp_shrinker_top</code></a> and <a href="index.html#val-const_exp_shrinker_bot"><code>const_exp_shrinker_bot</code></a></p></dd></dl><dl><dt class="spec value" id="val-const_exp"><a href="#val-const_exp" class="anchor"></a><code><span class="keyword">val</span> const_exp : <span><a href="../ExpGen/ExpT/index.html#type-t">ExpGen.ExpT.t</a> <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.arbitrary</span></code></dt><dt class="spec value" id="val-concrete_eval"><a href="#val-concrete_eval" class="anchor"></a><code><span class="keyword">val</span> concrete_eval : <a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t</code></dt><dt class="spec value" id="val-tests"><a href="#val-tests" class="anchor"></a><code><span class="keyword">val</span> tests : <span><a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t list</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ConcreteEvalT (read-dwarf.Tests.ConcreteEvalT)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; ConcreteEvalT</nav><header class="odoc-preamble"><h1>Module <code><span>Tests.ConcreteEvalT</span></code></h1><p>This module is for testing <a href="../../Exp/ConcreteEval/index.html"><code>ConcreteEval</code></a></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-ConcreteEval"><a href="#module-ConcreteEval" class="anchor"></a><code><span><span class="keyword">module</span> ConcreteEval</span><span> = <a href="../../Exp/ConcreteEval/index.html">Exp.ConcreteEval</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Value"><a href="#module-Value" class="anchor"></a><code><span><span class="keyword">module</span> Value</span><span> = <a href="../../Exp/Value/index.html">Exp.Value</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span><span class="keyword">module</span> Typed</span><span> = <a href="../../Exp/Typed/index.html">Exp.Typed</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_gen_ty"><a href="#val-const_exp_gen_ty" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_gen_ty : 
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_gen"><a href="#val-const_exp_gen" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_gen : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_shrinker_top"><a href="#val-const_exp_shrinker_top" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_shrinker_top : 
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Shrink by trying all sub expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_shrinker_bot"><a href="#val-const_exp_shrinker_bot" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_shrinker_bot : 
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span><span>(<span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Shrink by replacing a non-atomic constant expression by it's constEval evaluation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_shrinker"><a href="#val-const_exp_shrinker" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_shrinker : 
+  <span><span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Shrink by using both <a href="#val-const_exp_shrinker_top"><code>const_exp_shrinker_top</code></a> and <a href="#val-const_exp_shrinker_bot"><code>const_exp_shrinker_bot</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp"><a href="#val-const_exp" class="anchor"></a><code><span><span class="keyword">val</span> const_exp : <span><a href="../ExpGen/ExpT/index.html#type-t">ExpGen.ExpT.t</a> <span class="xref-unresolved">Tests</span>.Common.Q.arbitrary</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concrete_eval"><a href="#val-concrete_eval" class="anchor"></a><code><span><span class="keyword">val</span> concrete_eval : <span class="xref-unresolved">Tests</span>.Common.QCT.t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tests"><a href="#val-tests" class="anchor"></a><code><span><span class="keyword">val</span> tests : <span><span class="xref-unresolved">Tests</span>.Common.QCT.t list</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ExpGen/ExpT/index.html b/doc/html/read-dwarf/Tests/ExpGen/ExpT/index.html
index 9581053d..138cb8f3 100644
--- a/doc/html/read-dwarf/Tests/ExpGen/ExpT/index.html
+++ b/doc/html/read-dwarf/Tests/ExpGen/ExpT/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ExpT (read-dwarf.Tests.ExpGen.ExpT)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; ExpT</nav><h1>Module <code>ExpGen.ExpT</code></h1></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../Var/index.html#type-t">Var.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span class="keyword">val</span> of_var : <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span class="keyword">val</span> add_type : <span><span>(<span class="type-var">'a</span>, <a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ExpT (read-dwarf.Tests.ExpGen.ExpT)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; ExpT</nav><header class="odoc-preamble"><h1>Module <code><span>ExpGen.ExpT</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../Var/index.html#type-t">Var.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span><span class="keyword">val</span> of_var : <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span><span class="keyword">val</span> add_type : <span><span><span>(<span class="type-var">'a</span>, <a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ExpGen/Gen/index.html b/doc/html/read-dwarf/Tests/ExpGen/Gen/index.html
index 9b97bcb2..efe3a391 100644
--- a/doc/html/read-dwarf/Tests/ExpGen/Gen/index.html
+++ b/doc/html/read-dwarf/Tests/ExpGen/Gen/index.html
@@ -1,2 +1,5 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Gen (read-dwarf.Tests.ExpGen.Gen)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; Gen</nav><h1>Module <code>ExpGen.Gen</code></h1></header><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>('v, 'm) exp</span></code><code> = <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><dl><dt class="spec value" id="val-typ"><a href="#val-typ" class="anchor"></a><code><span class="keyword">val</span> typ : <span><span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-var_from_ty"><a href="#val-var_from_ty" class="anchor"></a><code><span class="keyword">val</span> var_from_ty : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bv_var"><a href="#val-bv_var" class="anchor"></a><code><span class="keyword">val</span> bv_var : int <span>&#45;&gt;</span> <span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bool_var"><a href="#val-bool_var" class="anchor"></a><code><span class="keyword">val</span> bool_var : <span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bitvec_size"><a href="#val-bitvec_size" class="anchor"></a><code><span class="keyword">val</span> bitvec_size : <span><a href="../../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.sized</span></code></dt><dt class="spec value" id="val-bitvec"><a href="#val-bitvec" class="anchor"></a><code><span class="keyword">val</span> bitvec : <span><a href="../../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt></dl><dl><dt class="spec type" id="type-gen_param"><a href="#type-gen_param" class="anchor"></a><code><span class="keyword">type</span> <span>('v, 'm) gen_param</span></code><code> = </code><code>{</code><table class="record"><tr id="type-gen_param.typ" class="anchored"><td class="def field"><a href="#type-gen_param.typ" class="anchor"></a><code>typ : <span><a href="../../../Ast/index.html#type-no">Ast.no</a> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>;</code></td><td class="doc"><p>Cannot contain an enum</p></td></tr><tr id="type-gen_param.size" class="anchored"><td class="def field"><a href="#type-gen_param.size" class="anchor"></a><code>size : int;</code></td></tr><tr id="type-gen_param.bv_atom_gen" class="anchored"><td class="def field"><a href="#type-gen_param.bv_atom_gen" class="anchor"></a><code>bv_atom_gen : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.sized</span>;</code></td></tr><tr id="type-gen_param.bool_atom_gen" class="anchored"><td class="def field"><a href="#type-gen_param.bool_atom_gen" class="anchor"></a><code>bool_atom_gen : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="index.html#type-exp">exp</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span>;</code></td></tr></table><code>}</code></dt></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>params:<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-gen_param">gen_param</a></span></span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-exp">exp</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dd><p>Generate an atom according to the <code>params</code></p></dd></dl><dl><dt class="spec value" id="val-unop"><a href="#val-unop" class="anchor"></a><code><span class="keyword">val</span> unop : <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <span><span>(<a href="../../../Ast/index.html#type-unop">Ast.unop</a> * <span><span class="type-var">'b</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-binop"><a href="#val-binop" class="anchor"></a><code><span class="keyword">val</span> binop : <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <span><span>(<span><span class="type-var">'b</span> <a href="../../../Ast/index.html#type-binop">Ast.binop</a></span> * <span><span class="type-var">'c</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> * <span><span class="type-var">'c</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-manyop"><a href="#val-manyop" class="anchor"></a><code><span class="keyword">val</span> manyop : <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <span><span>(<a href="../../../Ast/index.html#type-manyop">Ast.manyop</a> * <span><span><span class="type-var">'b</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <a href="../../../Utils/index.html#module-List">Utils.List</a>.t</span>)</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-exp_from_params"><a href="#val-exp_from_params" class="anchor"></a><code><span class="keyword">val</span> exp_from_params : <span><span>(<span class="type-var">'a</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="index.html#type-gen_param">gen_param</a></span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'a</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="index.html#type-exp">exp</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bv_consts"><a href="#val-bv_consts" class="anchor"></a><code><span class="keyword">val</span> bv_consts : int <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bv_atom_from_var"><a href="#val-bv_atom_from_var" class="anchor"></a><code><span class="keyword">val</span> bv_atom_from_var : <span><span class="type-var">'v</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.sized</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'a</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bv_atom_with_var"><a href="#val-bv_atom_with_var" class="anchor"></a><code><span class="keyword">val</span> bv_atom_with_var : int <span>&#45;&gt;</span> <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bool_consts"><a href="#val-bool_consts" class="anchor"></a><code><span class="keyword">val</span> bool_consts : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bool_atom_from_var"><a href="#val-bool_atom_from_var" class="anchor"></a><code><span class="keyword">val</span> bool_atom_from_var : <span><span class="type-var">'v</span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span> <span>&#45;&gt;</span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'a</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-bool_atom_with_var"><a href="#val-bool_atom_with_var" class="anchor"></a><code><span class="keyword">val</span> bool_atom_with_var : <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Gen (read-dwarf.Tests.ExpGen.Gen)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; Gen</nav><header class="odoc-preamble"><h1>Module <code><span>ExpGen.Gen</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>('v, 'm) exp</span></span><span> = <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-typ"><a href="#val-typ" class="anchor"></a><code><span><span class="keyword">val</span> typ : <span><span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-var_from_ty"><a href="#val-var_from_ty" class="anchor"></a><code><span><span class="keyword">val</span> var_from_ty : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bv_var"><a href="#val-bv_var" class="anchor"></a><code><span><span class="keyword">val</span> bv_var : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool_var"><a href="#val-bool_var" class="anchor"></a><code><span><span class="keyword">val</span> bool_var : <span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bitvec_size"><a href="#val-bitvec_size" class="anchor"></a><code><span><span class="keyword">val</span> bitvec_size : <span><a href="../../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <a href="../../Common/Gen/index.html#type-sized">Common.Gen.sized</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bitvec"><a href="#val-bitvec" class="anchor"></a><code><span><span class="keyword">val</span> bitvec : <span><a href="../../../Utils/BitVec/index.html#type-t">Utils.BitVec.t</a> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-gen_param"><a href="#type-gen_param" class="anchor"></a><code><span><span class="keyword">type</span> <span>('v, 'm) gen_param</span></span><span> = </span><span>{</span></code><ol><li id="type-gen_param.typ" class="def record field anchored"><a href="#type-gen_param.typ" class="anchor"></a><code><span>typ : <span><a href="../../../Ast/index.html#type-no">Ast.no</a> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Cannot contain an enum</p><span class="comment-delim">*)</span></div></li><li id="type-gen_param.size" class="def record field anchored"><a href="#type-gen_param.size" class="anchor"></a><code><span>size : int;</span></code></li><li id="type-gen_param.bv_atom_gen" class="def record field anchored"><a href="#type-gen_param.bv_atom_gen" class="anchor"></a><code><span>bv_atom_gen : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> <a href="../../Common/Gen/index.html#type-sized">Common.Gen.sized</a></span>;</span></code></li><li id="type-gen_param.bool_atom_gen" class="def record field anchored"><a href="#type-gen_param.bool_atom_gen" class="anchor"></a><code><span>bool_atom_gen : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="#type-exp">exp</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span>;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span><span class="keyword">val</span> atom : <span><span class="label">params</span>:<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-gen_param">gen_param</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-exp">exp</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div><div class="spec-doc"><p>Generate an atom according to the <code>params</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unop"><a href="#val-unop" class="anchor"></a><code><span><span class="keyword">val</span> unop : <span><span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../../../Ast/index.html#type-unop">Ast.unop</a> * <span><span class="type-var">'b</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-binop"><a href="#val-binop" class="anchor"></a><code><span><span class="keyword">val</span> binop : <span><span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <a href="../../../Ast/index.html#type-binop">Ast.binop</a></span> * <span><span class="type-var">'c</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> * <span><span class="type-var">'c</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>)</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-manyop"><a href="#val-manyop" class="anchor"></a><code><span><span class="keyword">val</span> manyop : <span><span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="../../../Ast/index.html#type-manyop">Ast.manyop</a> * <span><span><span class="type-var">'b</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span> <a href="../../../Utils/List/index.html#type-t">Utils.List.t</a></span>)</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_from_params"><a href="#val-exp_from_params" class="anchor"></a><code><span><span class="keyword">val</span> exp_from_params : <span><span><span>(<span class="type-var">'a</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="#type-gen_param">gen_param</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="#type-exp">exp</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bv_consts"><a href="#val-bv_consts" class="anchor"></a><code><span><span class="keyword">val</span> bv_consts : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bv_atom_from_var"><a href="#val-bv_atom_from_var" class="anchor"></a><code><span><span class="keyword">val</span> bv_atom_from_var : 
+  <span><span><span class="type-var">'v</span> <a href="../../Common/Gen/index.html#type-sized">Common.Gen.sized</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'a</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bv_atom_with_var"><a href="#val-bv_atom_with_var" class="anchor"></a><code><span><span class="keyword">val</span> bv_atom_with_var : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool_consts"><a href="#val-bool_consts" class="anchor"></a><code><span><span class="keyword">val</span> bool_consts : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool_atom_from_var"><a href="#val-bool_atom_from_var" class="anchor"></a><code><span><span class="keyword">val</span> bool_atom_from_var : <span><span><span class="type-var">'v</span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'a</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool_atom_with_var"><a href="#val-bool_atom_with_var" class="anchor"></a><code><span><span class="keyword">val</span> bool_atom_with_var : <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'b</span>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ExpGen/Var/index.html b/doc/html/read-dwarf/Tests/ExpGen/Var/index.html
index a690e2e0..466cba02 100644
--- a/doc/html/read-dwarf/Tests/ExpGen/Var/index.html
+++ b/doc/html/read-dwarf/Tests/ExpGen/Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Tests.ExpGen.Var)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; Var</nav><h1>Module <code>ExpGen.Var</code></h1><p>Test variables to instantiate variable dependent functors for testing.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = int * <span><a href="../../../Ast/index.html#type-no">Ast.no</a> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span></code></dt></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <span class="type-var">'a</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Tests.ExpGen.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Module <code><span>ExpGen.Var</span></code></h1><p>Test variables to instantiate variable dependent functors for testing.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = int * <span><a href="../../../Ast/index.html#type-no">Ast.no</a> <a href="../../../Ast/index.html#type-ty">Ast.ty</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ExpGen/Z3/Htbl/index.html b/doc/html/read-dwarf/Tests/ExpGen/Z3/Htbl/index.html
index 1ec7ea60..5b06f439 100644
--- a/doc/html/read-dwarf/Tests/ExpGen/Z3/Htbl/index.html
+++ b/doc/html/read-dwarf/Tests/ExpGen/Z3/Htbl/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Htbl (read-dwarf.Tests.ExpGen.Z3.Htbl)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Tests</a> &#x00BB; <a href="../../index.html">ExpGen</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; Htbl</nav><h1>Module <code>Z3.Htbl</code></h1></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../index.html#type-var">var</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> <a href="../../../../Z3/Make/index.html#module-Htbl">Z3.Make(Var).Htbl</a>.t</span></code></dt></dl><dl><dt class="spec value" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span class="keyword">val</span> reset : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span class="keyword">val</span> find_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span class="keyword">val</span> find_all : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span class="keyword">val</span> replace : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span class="keyword">val</span> filter_map_inplace : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span class="keyword">val</span> stats : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> Stdlib.Hashtbl.statistics</code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span class="keyword">val</span> to_seq_keys : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-key">key</a> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span class="keyword">val</span> to_seq_values : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span class="keyword">val</span> add_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span class="keyword">val</span> replace_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Htbl (read-dwarf.Tests.ExpGen.Z3.Htbl)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Tests</a> &#x00BB; <a href="../../index.html">ExpGen</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; Htbl</nav><header class="odoc-preamble"><h1>Module <code><span>Z3.Htbl</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../index.html#type-var">var</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Z3</span>.Make(<span class="xref-unresolved">Var</span>).Htbl.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span><span class="keyword">val</span> replace : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span><span class="keyword">val</span> filter_map_inplace : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span><span class="keyword">val</span> stats : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib__Hashtbl</span>.statistics</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_keys : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_values : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span><span class="keyword">val</span> add_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span><span class="keyword">val</span> replace_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ExpGen/Z3/index.html b/doc/html/read-dwarf/Tests/ExpGen/Z3/index.html
index eabe996a..a2e3e599 100644
--- a/doc/html/read-dwarf/Tests/ExpGen/Z3/index.html
+++ b/doc/html/read-dwarf/Tests/ExpGen/Z3/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3 (read-dwarf.Tests.ExpGen.Z3)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; Z3</nav><h1>Module <code>ExpGen.Z3</code></h1></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../Var/index.html#type-t">Var.t</a></code></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><div class="spec module" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span class="keyword">module</span> <a href="Htbl/index.html">Htbl</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span class="keyword">val</span> declare_var_always : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span class="keyword">val</span> declare_var : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span class="keyword">val</span> declare_vars : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span class="keyword">val</span> simplify_decl : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span class="keyword">val</span> send_assert : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span class="keyword">val</span> send_assert_decl : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-check"><a href="#val-check" class="anchor"></a><code><span class="keyword">val</span> check : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span class="keyword">val</span> check_sat : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span class="keyword">val</span> check_both : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span class="keyword">val</span> simplify_full : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span class="keyword">val</span> check_full : <span>?&#8288;hyps:<span><a href="index.html#type-exp">exp</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span class="keyword">val</span> check_sat_full : <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> <span>bool option</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3 (read-dwarf.Tests.ExpGen.Z3)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Tests</a> &#x00BB; <a href="../index.html">ExpGen</a> &#x00BB; Z3</nav><header class="odoc-preamble"><h1>Module <code><span>ExpGen.Z3</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../Var/index.html#type-t">Var.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Htbl/index.html">Htbl</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span><span class="keyword">val</span> declare_var_always : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span><span class="keyword">val</span> declare_var : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span><span class="keyword">val</span> declare_vars : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span><span class="keyword">val</span> send_assert : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span><span class="keyword">val</span> send_assert_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check"><a href="#val-check" class="anchor"></a><code><span><span class="keyword">val</span> check : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span><span class="keyword">val</span> check_sat : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span><span class="keyword">val</span> check_both : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms"><a href="#val-simplify_subterms" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_decl"><a href="#val-simplify_subterms_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_full : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span><span class="keyword">val</span> check_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span><span class="keyword">val</span> check_sat_full : <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_full"><a href="#val-simplify_subterms_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/ExpGen/index.html b/doc/html/read-dwarf/Tests/ExpGen/index.html
index 4fac6aa8..fbaa5639 100644
--- a/doc/html/read-dwarf/Tests/ExpGen/index.html
+++ b/doc/html/read-dwarf/Tests/ExpGen/index.html
@@ -1,2 +1,9 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ExpGen (read-dwarf.Tests.ExpGen)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; ExpGen</nav><h1>Module <code>Tests.ExpGen</code></h1></header><aside><p>This module try to provide generic generators and arbitrary to work with expressions.</p><p>For now expression do not use enumeration since the Z3 back-end don't support enumeration yet.</p></aside><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> <span>('v, 'm) exp</span></code><code> = <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><dl><dt class="spec module" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span class="keyword">module</span> <a href="Var/index.html">Var</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Test variables to instantiate variable dependent functors for testing.</p></dd></dl><div class="spec module" id="module-ExpT"><a href="#module-ExpT" class="anchor"></a><code><span class="keyword">module</span> <a href="ExpT/index.html">ExpT</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Z3"><a href="#module-Z3" class="anchor"></a><code><span class="keyword">module</span> <a href="Z3/index.html">Z3</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Gen"><a href="#module-Gen" class="anchor"></a><code><span class="keyword">module</span> <a href="Gen/index.html">Gen</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-shrink_propagate"><a href="#val-shrink_propagate" class="anchor"></a><code><span class="keyword">val</span> shrink_propagate : <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.Shrink.t</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span>&#45;&gt;</span> <span>(<span><span>(<span><span class="type-var">'m</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <span class="type-var">'v</span>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <span class="type-var">'m</span>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Propagate an existing shrinker, by try it on all descendants of this. The The provided shrinker must preserve the type.</p></dd></dl><dl><dt class="spec value" id="val-from_gen"><a href="#val-from_gen" class="anchor"></a><code><span class="keyword">val</span> from_gen : <span>?&#8288;shrink:<span><a href="ExpT/index.html#type-t">ExpT.t</a> <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.Shrink.t</span></span> <span>&#45;&gt;</span> <span><span><span>(<a href="ExpT/index.html#type-var">ExpT.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="index.html#type-exp">exp</a></span> <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.Gen.t</span> <span>&#45;&gt;</span> <span><a href="ExpT/index.html#type-t">ExpT.t</a> <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.arbitrary</span></code></dt><dd><p>Generate an expression arbitrary from a generator (and optionally a <code>shrink</code>er)</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ExpGen (read-dwarf.Tests.ExpGen)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; ExpGen</nav><header class="odoc-preamble"><h1>Module <code><span>Tests.ExpGen</span></code></h1><p>This module try to provide generic generators and arbitrary to work with expressions.</p><p>For now expression do not use enumeration since the Z3 back-end don't support enumeration yet.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> <span>('v, 'm) exp</span></span><span> = <span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Var/index.html">Var</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Test variables to instantiate variable dependent functors for testing.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ExpT"><a href="#module-ExpT" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ExpT/index.html">ExpT</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Z3"><a href="#module-Z3" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Z3/index.html">Z3</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Gen"><a href="#module-Gen" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Gen/index.html">Gen</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shrink_propagate"><a href="#val-shrink_propagate" class="anchor"></a><code><span><span class="keyword">val</span> shrink_propagate : 
+  <span><span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span class="xref-unresolved">Tests</span>.Common.Q.Shrink.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span><span>(<span class="type-var">'v</span>, <span class="type-var">'m</span>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Propagate an existing shrinker, by try it on all descendants of this. The The provided shrinker must preserve the type.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-from_gen"><a href="#val-from_gen" class="anchor"></a><code><span><span class="keyword">val</span> from_gen : 
+  <span><span class="optlabel">?shrink</span>:<span><a href="ExpT/index.html#type-t">ExpT.t</a> <span class="xref-unresolved">Tests</span>.Common.Q.Shrink.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span><span>(<a href="ExpT/index.html#type-var">ExpT.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="#type-exp">exp</a></span> <span class="xref-unresolved">Tests</span>.Common.Q.Gen.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="ExpT/index.html#type-t">ExpT.t</a> <span class="xref-unresolved">Tests</span>.Common.Q.arbitrary</span></span></code></div><div class="spec-doc"><p>Generate an expression arbitrary from a generator (and optionally a <code>shrink</code>er)</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/SimplifyCheck/index.html b/doc/html/read-dwarf/Tests/SimplifyCheck/index.html
index 3ed79d0f..d3f1188c 100644
--- a/doc/html/read-dwarf/Tests/SimplifyCheck/index.html
+++ b/doc/html/read-dwarf/Tests/SimplifyCheck/index.html
@@ -1,2 +1,14 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SimplifyCheck (read-dwarf.Tests.SimplifyCheck)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; SimplifyCheck</nav><h1>Module <code>Tests.SimplifyCheck</code></h1></header><aside><p>This module is about testing Z3 simplify against Z3 check. It's not really about testing Z3 itself but about testing our parsing of Z3 expression output (in particular let bindings unfolding)</p></aside><dl><dt class="spec value" id="val-var_exp_gen_ty"><a href="#val-var_exp_gen_ty" class="anchor"></a><code><span class="keyword">val</span> var_exp_gen_ty : int <span>&#45;&gt;</span> <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-var_exp_gen"><a href="#val-var_exp_gen" class="anchor"></a><code><span class="keyword">val</span> var_exp_gen : int <span>&#45;&gt;</span> <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../../Tests__Common/index.html#module-Gen">Tests.Common.Gen</a>.t</span></code></dt><dt class="spec value" id="val-const_exp_shrinker_top"><a href="#val-const_exp_shrinker_top" class="anchor"></a><code><span class="keyword">val</span> const_exp_shrinker_top : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span>&#45;&gt;</span> <span>(<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Shrink by trying all sub expressions</p></dd></dl><dl><dt class="spec value" id="val-const_exp_shrinker_bot"><a href="#val-const_exp_shrinker_bot" class="anchor"></a><code><span class="keyword">val</span> const_exp_shrinker_bot : <span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../ExpGen/Z3/index.html#type-var">ExpGen.Z3.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <span>(<a href="../ExpGen/Z3/index.html#type-exp">ExpGen.Z3.exp</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Shrink by replacing a non-atomic expression by it's simplified version</p></dd></dl><dl><dt class="spec value" id="val-const_exp_shrinker"><a href="#val-const_exp_shrinker" class="anchor"></a><code><span class="keyword">val</span> const_exp_shrinker : <span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../ExpGen/Z3/index.html#type-var">ExpGen.Z3.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span>&#45;&gt;</span> <span>(<span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../ExpGen/Z3/index.html#type-var">ExpGen.Z3.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Shrink by using both <a href="index.html#val-const_exp_shrinker_top"><code>const_exp_shrinker_top</code></a> and <a href="index.html#val-const_exp_shrinker_bot"><code>const_exp_shrinker_bot</code></a></p></dd></dl><dl><dt class="spec value" id="val-var_exp"><a href="#val-var_exp" class="anchor"></a><code><span class="keyword">val</span> var_exp : <span><a href="../ExpGen/ExpT/index.html#type-t">ExpGen.ExpT.t</a> <a href="../Common/index.html#module-Q">Tests.Common.Q</a>.arbitrary</span></code></dt><dt class="spec value" id="val-simplify_check"><a href="#val-simplify_check" class="anchor"></a><code><span class="keyword">val</span> simplify_check : <a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t</code></dt><dt class="spec value" id="val-tests"><a href="#val-tests" class="anchor"></a><code><span class="keyword">val</span> tests : <span><a href="../Common/index.html#module-QCT">Tests.Common.QCT</a>.t list</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SimplifyCheck (read-dwarf.Tests.SimplifyCheck)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Tests</a> &#x00BB; SimplifyCheck</nav><header class="odoc-preamble"><h1>Module <code><span>Tests.SimplifyCheck</span></code></h1><p>This module is about testing Z3 simplify against Z3 check. It's not really about testing Z3 itself but about testing our parsing of Z3 expression output (in particular let bindings unfolding)</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-var_exp_gen_ty"><a href="#val-var_exp_gen_ty" class="anchor"></a><code><span><span class="keyword">val</span> var_exp_gen_ty : 
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-var_exp_gen"><a href="#val-var_exp_gen" class="anchor"></a><code><span><span class="keyword">val</span> var_exp_gen : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span>(int * <span><span class="type-var">'a</span> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../ExpGen/Gen/index.html#type-exp">ExpGen.Gen.exp</a></span> <a href="../Common/Gen/index.html#type-t">Common.Gen.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_shrinker_top"><a href="#val-const_exp_shrinker_top" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_shrinker_top : 
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>, <span class="type-var">'c</span>, <span class="type-var">'d</span>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Shrink by trying all sub expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_shrinker_bot"><a href="#val-const_exp_shrinker_bot" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_shrinker_bot : 
+  <span><span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../ExpGen/Z3/index.html#type-var">ExpGen.Z3.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><a href="../ExpGen/Z3/index.html#type-exp">ExpGen.Z3.exp</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Shrink by replacing a non-atomic expression by it's simplified version</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const_exp_shrinker"><a href="#val-const_exp_shrinker" class="anchor"></a><code><span><span class="keyword">val</span> const_exp_shrinker : 
+  <span><span><span>(<span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span>, <a href="../ExpGen/Z3/index.html#type-var">ExpGen.Z3.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/Base/index.html#type-exp">Ast.Base.exp</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span><span>(<a href="../ExpGen/Z3/index.html#type-var">ExpGen.Z3.var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Shrink by using both <a href="#val-const_exp_shrinker_top"><code>const_exp_shrinker_top</code></a> and <a href="#val-const_exp_shrinker_bot"><code>const_exp_shrinker_bot</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-var_exp"><a href="#val-var_exp" class="anchor"></a><code><span><span class="keyword">val</span> var_exp : <span><a href="../ExpGen/ExpT/index.html#type-t">ExpGen.ExpT.t</a> <span class="xref-unresolved">Tests</span>.Common.Q.arbitrary</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_check"><a href="#val-simplify_check" class="anchor"></a><code><span><span class="keyword">val</span> simplify_check : <span class="xref-unresolved">Tests</span>.Common.QCT.t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tests"><a href="#val-tests" class="anchor"></a><code><span><span class="keyword">val</span> tests : <span><span class="xref-unresolved">Tests</span>.Common.QCT.t list</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Tests/index.html b/doc/html/read-dwarf/Tests/index.html
index 1432d216..218eb149 100644
--- a/doc/html/read-dwarf/Tests/index.html
+++ b/doc/html/read-dwarf/Tests/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Tests (read-dwarf.Tests)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Tests</nav><h1>Module <code>Tests</code></h1></header><dl><dt class="spec module" id="module-BytesSeqT"><a href="#module-BytesSeqT" class="anchor"></a><code><span class="keyword">module</span> <a href="BytesSeqT/index.html">BytesSeqT</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Common"><a href="#module-Common" class="anchor"></a><code><span class="keyword">module</span> <a href="Common/index.html">Common</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-ConcreteEvalT"><a href="#module-ConcreteEvalT" class="anchor"></a><code><span class="keyword">module</span> <a href="ConcreteEvalT/index.html">ConcreteEvalT</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-ExpGen"><a href="#module-ExpGen" class="anchor"></a><code><span class="keyword">module</span> <a href="ExpGen/index.html">ExpGen</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-SimplifyCheck"><a href="#module-SimplifyCheck" class="anchor"></a><code><span class="keyword">module</span> <a href="SimplifyCheck/index.html">SimplifyCheck</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Tests (read-dwarf.Tests)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Tests</nav><header class="odoc-preamble"><h1>Module <code><span>Tests</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-BytesSeqT"><a href="#module-BytesSeqT" class="anchor"></a><code><span><span class="keyword">module</span> <a href="BytesSeqT/index.html">BytesSeqT</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Common"><a href="#module-Common" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Common/index.html">Common</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ConcreteEvalT"><a href="#module-ConcreteEvalT" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ConcreteEvalT/index.html">ConcreteEvalT</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is for testing <a href="../Exp/ConcreteEval/index.html"><code>ConcreteEval</code></a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ExpGen"><a href="#module-ExpGen" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ExpGen/index.html">ExpGen</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module try to provide generic generators and arbitrary to work with expressions.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SimplifyCheck"><a href="#module-SimplifyCheck" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SimplifyCheck/index.html">SimplifyCheck</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is about testing Z3 simplify against Z3 check. It's not really about testing Z3 itself but about testing our parsing of Z3 expression output (in particular let bindings unfolding)</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/Exp/index.html b/doc/html/read-dwarf/Trace/Base/Exp/index.html
index d8a88a78..e58de2b9 100644
--- a/doc/html/read-dwarf/Trace/Base/Exp/index.html
+++ b/doc/html/read-dwarf/Trace/Base/Exp/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Exp (read-dwarf.Trace.Base.Exp)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Exp</nav><h1>Module <code>Base.Exp</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></code></span></summary><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../Var/index.html#type-t">Var.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dt class="spec value" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span class="keyword">val</span> of_var : <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span class="keyword">val</span> add_type : <span><span>(<span class="type-var">'a</span>, <a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span class="keyword">val</span> of_reg : <a href="../../../State/Reg/index.html#type-t">Var.Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Exp (read-dwarf.Trace.Base.Exp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Exp</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Exp</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../Var/index.html#type-t">Var.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_var"><a href="#val-of_var" class="anchor"></a><code><span><span class="keyword">val</span> of_var : <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_type"><a href="#val-add_type" class="anchor"></a><code><span><span class="keyword">val</span> add_type : <span><span><span>(<span class="type-var">'a</span>, <a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span><span class="keyword">val</span> of_reg : <span><a href="../../../State/Reg/index.html#type-t">Var.Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/SimpContext/index.html b/doc/html/read-dwarf/Trace/Base/SimpContext/index.html
index e704dd0a..2993946e 100644
--- a/doc/html/read-dwarf/Trace/Base/SimpContext/index.html
+++ b/doc/html/read-dwarf/Trace/Base/SimpContext/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SimpContext (read-dwarf.Trace.Base.SimpContext)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; SimpContext</nav><h1>Module <code>Base.SimpContext</code></h1><p>A instance of <a href="../../../Z3/ContextCounter/index.html"><code>Z3.ContextCounter</code></a>.</p></header><dl><dt class="spec value" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span class="keyword">val</span> counter : <a href="../../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></code></dt><dt class="spec value" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span class="keyword">val</span> openc : unit <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-num"><a href="#val-num" class="anchor"></a><code><span class="keyword">val</span> num : unit <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span class="keyword">val</span> closec : unit <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SimpContext (read-dwarf.Trace.Base.SimpContext)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; SimpContext</nav><header class="odoc-preamble"><h1>Module <code><span>Base.SimpContext</span></code></h1><p>A instance of <a href="../../../Z3/ContextCounter/index.html"><code>Z3.ContextCounter</code></a>.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span><span class="keyword">val</span> counter : <a href="../../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span><span class="keyword">val</span> openc : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-num"><a href="#val-num" class="anchor"></a><code><span><span class="keyword">val</span> num : <span>unit <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span><span class="keyword">val</span> closec : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/Var/index.html b/doc/html/read-dwarf/Trace/Base/Var/index.html
index e7f3f03e..5c0a9f6c 100644
--- a/doc/html/read-dwarf/Trace/Base/Var/index.html
+++ b/doc/html/read-dwarf/Trace/Base/Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Trace.Base.Var)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Var</nav><h1>Module <code>Base.Var</code></h1><p>This module contains variable used in traces</p></header><div class="spec module" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span class="keyword">module</span> Reg = <a href="../../../State/index.html#module-Reg">State.Reg</a></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><table class="variant"><tr id="type-t.Register" class="anchored"><td class="def constructor"><a href="#type-t.Register" class="anchor"></a><code>| </code><code><span class="constructor">Register</span> <span class="keyword">of</span> <a href="../../../State/Reg/index.html#type-t">Reg.t</a></code></td><td class="doc"><p>The value of the register at the beginning of the trace</p></td></tr><tr id="type-t.Read" class="anchored"><td class="def constructor"><a href="#type-t.Read" class="anchor"></a><code>| </code><code><span class="constructor">Read</span> <span class="keyword">of</span> int * <a href="../../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></code></td><td class="doc"><p>The result of that memory reading operation</p></td></tr><tr id="type-t.NonDet" class="anchored"><td class="def constructor"><a href="#type-t.NonDet" class="anchor"></a><code>| </code><code><span class="constructor">NonDet</span> <span class="keyword">of</span> int * <a href="../../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a></code></td><td class="doc"><p>Variable representing non-determinism in the spec</p></td></tr></table></dt><dd><p>A trace variable</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert the variable to the string encoding. For parsing infractructure reason, the encoding must always contain at least one <code>:</code>.</p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Inverse of <a href="index.html#val-to_string"><code>to_string</code></a></p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints the variable</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <span class="type-var">'a</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../State/Reg/index.html#type-ty">Reg.ty</a></code></dt><dt class="spec value" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span class="keyword">val</span> of_reg : <a href="../../../State/Reg/index.html#type-t">Reg.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Trace.Base.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Var</span></code></h1><p>This module contains variable used in traces</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span><span class="keyword">module</span> Reg</span><span> = <a href="../../../State/Reg/index.html">State.Reg</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span></code><ol><li id="type-t.Register" class="def variant constructor anchored"><a href="#type-t.Register" class="anchor"></a><code><span>| </span><span><span class="constructor">Register</span> <span class="keyword">of</span> <a href="../../../State/Reg/index.html#type-t">Reg.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The value of the register at the beginning of the trace</p><span class="comment-delim">*)</span></div></li><li id="type-t.Read" class="def variant constructor anchored"><a href="#type-t.Read" class="anchor"></a><code><span>| </span><span><span class="constructor">Read</span> <span class="keyword">of</span> int * <a href="../../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The result of that memory reading operation</p><span class="comment-delim">*)</span></div></li><li id="type-t.NonDet" class="def variant constructor anchored"><a href="#type-t.NonDet" class="anchor"></a><code><span>| </span><span><span class="constructor">NonDet</span> <span class="keyword">of</span> int * <a href="../../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Variable representing non-determinism in the spec</p><span class="comment-delim">*)</span></div></li><li id="type-t.Segment" class="def variant constructor anchored"><a href="#type-t.Segment" class="anchor"></a><code><span>| </span><span><span class="constructor">Segment</span> <span class="keyword">of</span> string * int</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Variable representing symbolic segment in the opcode</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>A trace variable</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert the variable to the string encoding. For parsing infractructure reason, the encoding must always contain at least one <code>:</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Inverse of <a href="#val-to_string"><code>to_string</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints the variable</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../State/Reg/index.html#type-ty">Reg.ty</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_reg"><a href="#val-of_reg" class="anchor"></a><code><span><span class="keyword">val</span> of_reg : <span><a href="../../../State/Reg/index.html#type-t">Reg.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/VarTbl/index.html b/doc/html/read-dwarf/Trace/Base/VarTbl/index.html
index 62a8cb19..7df27d58 100644
--- a/doc/html/read-dwarf/Trace/Base/VarTbl/index.html
+++ b/doc/html/read-dwarf/Trace/Base/VarTbl/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>VarTbl (read-dwarf.Trace.Base.VarTbl)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; VarTbl</nav><h1>Module <code>Base.VarTbl</code></h1></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../Var/index.html#type-t">Var.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> Stdlib__hashtbl.Make(<a href="../index.html#module-Var">Var</a>).t</span></code></dt></dl><dl><dt class="spec value" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span class="keyword">val</span> reset : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span class="keyword">val</span> find_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span class="keyword">val</span> find_all : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span class="keyword">val</span> replace : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span class="keyword">val</span> filter_map_inplace : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span class="keyword">val</span> stats : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> Stdlib__hashtbl.statistics</code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span class="keyword">val</span> to_seq_keys : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-key">key</a> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span class="keyword">val</span> to_seq_values : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span class="keyword">val</span> add_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span class="keyword">val</span> replace_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>VarTbl (read-dwarf.Trace.Base.VarTbl)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; VarTbl</nav><header class="odoc-preamble"><h1>Module <code><span>Base.VarTbl</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../Var/index.html#type-t">Var.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib__Hashtbl</span>.Make(<span class="xref-unresolved">Var</span>).t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span><span class="keyword">val</span> replace : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span><span class="keyword">val</span> filter_map_inplace : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span><span class="keyword">val</span> stats : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib__Hashtbl</span>.statistics</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_keys : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_values : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span><span class="keyword">val</span> add_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span><span class="keyword">val</span> replace_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/Z3Tr/Htbl/index.html b/doc/html/read-dwarf/Trace/Base/Z3Tr/Htbl/index.html
index ce6c218b..22802d81 100644
--- a/doc/html/read-dwarf/Trace/Base/Z3Tr/Htbl/index.html
+++ b/doc/html/read-dwarf/Trace/Base/Z3Tr/Htbl/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Htbl (read-dwarf.Trace.Base.Z3Tr.Htbl)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Trace</a> &#x00BB; <a href="../../index.html">Base</a> &#x00BB; <a href="../index.html">Z3Tr</a> &#x00BB; Htbl</nav><h1>Module <code>Z3Tr.Htbl</code></h1></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../index.html#type-var">var</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> <a href="../../../../Z3/Make/index.html#module-Htbl">Z3.Make(Var).Htbl</a>.t</span></code></dt></dl><dl><dt class="spec value" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span class="keyword">val</span> reset : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span class="keyword">val</span> find_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span class="keyword">val</span> find_all : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span class="keyword">val</span> replace : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span class="keyword">val</span> filter_map_inplace : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span class="keyword">val</span> stats : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> Stdlib.Hashtbl.statistics</code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span class="keyword">val</span> to_seq_keys : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><a href="index.html#type-key">key</a> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span class="keyword">val</span> to_seq_values : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span class="keyword">val</span> add_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span class="keyword">val</span> replace_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Htbl (read-dwarf.Trace.Base.Z3Tr.Htbl)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Trace</a> &#x00BB; <a href="../../index.html">Base</a> &#x00BB; <a href="../index.html">Z3Tr</a> &#x00BB; Htbl</nav><header class="odoc-preamble"><h1>Module <code><span>Z3Tr.Htbl</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../index.html#type-var">var</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Z3</span>.Make(<span class="xref-unresolved">Var</span>).Htbl.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace"><a href="#val-replace" class="anchor"></a><code><span><span class="keyword">val</span> replace : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map_inplace"><a href="#val-filter_map_inplace" class="anchor"></a><code><span><span class="keyword">val</span> filter_map_inplace : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stats"><a href="#val-stats" class="anchor"></a><code><span><span class="keyword">val</span> stats : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib__Hashtbl</span>.statistics</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_keys"><a href="#val-to_seq_keys" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_keys : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_values"><a href="#val-to_seq_values" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_values : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span><span class="keyword">val</span> add_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-replace_seq"><a href="#val-replace_seq" class="anchor"></a><code><span><span class="keyword">val</span> replace_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/Z3Tr/index.html b/doc/html/read-dwarf/Trace/Base/Z3Tr/index.html
index b361e7cf..fed8254f 100644
--- a/doc/html/read-dwarf/Trace/Base/Z3Tr/index.html
+++ b/doc/html/read-dwarf/Trace/Base/Z3Tr/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3Tr (read-dwarf.Trace.Base.Z3Tr)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Z3Tr</nav><h1>Module <code>Base.Z3Tr</code></h1></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="../Var/index.html#type-t">Var.t</a></code></dt><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt></dl><div class="spec module" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span class="keyword">module</span> <a href="Htbl/index.html">Htbl</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span class="keyword">val</span> declare_var_always : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span class="keyword">val</span> declare_var : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span class="keyword">val</span> declare_vars : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span class="keyword">val</span> simplify_decl : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span class="keyword">val</span> send_assert : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span class="keyword">val</span> send_assert_decl : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-check"><a href="#val-check" class="anchor"></a><code><span class="keyword">val</span> check : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span class="keyword">val</span> check_sat : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span class="keyword">val</span> check_both : <a href="../../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span class="keyword">val</span> simplify_full : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dt class="spec value" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span class="keyword">val</span> check_full : <span>?&#8288;hyps:<span><a href="index.html#type-exp">exp</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dt class="spec value" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span class="keyword">val</span> check_sat_full : <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> <span>bool option</span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3Tr (read-dwarf.Trace.Base.Z3Tr)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Base</a> &#x00BB; Z3Tr</nav><header class="odoc-preamble"><h1>Module <code><span>Base.Z3Tr</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="../Var/index.html#type-t">Var.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Htbl/index.html">Htbl</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span><span class="keyword">val</span> declare_var_always : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span><span class="keyword">val</span> declare_var : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span><span class="keyword">val</span> declare_vars : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span><span class="keyword">val</span> send_assert : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span><span class="keyword">val</span> send_assert_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check"><a href="#val-check" class="anchor"></a><code><span><span class="keyword">val</span> check : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span><span class="keyword">val</span> check_sat : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span><span class="keyword">val</span> check_both : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms"><a href="#val-simplify_subterms" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_decl"><a href="#val-simplify_subterms_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_decl : <span><a href="../../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <a href="Htbl/index.html#type-t">Htbl.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_full : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span><span class="keyword">val</span> check_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span><span class="keyword">val</span> check_sat_full : <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_full"><a href="#val-simplify_subterms_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Base/index.html b/doc/html/read-dwarf/Trace/Base/index.html
index 4cdf1c0d..d80a235a 100644
--- a/doc/html/read-dwarf/Trace/Base/index.html
+++ b/doc/html/read-dwarf/Trace/Base/index.html
@@ -1,3 +1,13 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Trace.Base)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Base</nav><h1>Module <code>Trace.Base</code></h1><p>This module defines a new simplified kind of trace to replace Isla traces in the later stages of the instruction semantics processing.</p><p>The traces are even simpler and more easily typable. The possible events are in the type <a href="index.html#type-event"><code>event</code></a> and traces (<a href="index.html#type-t"><code>t</code></a>) are just list of them.</p><p>Compared to Isla, the concept of reading a register do not exist anymore. Nor the concept of pure symbolic variable or Sail structured values. Instead expression can contain only registers and results of previous memory read as decribe in the type <a href="Var/index.html#type-t"><code>Var.t</code></a>. All writing event directly write an entire expression. There are no intermediary variable definitions.</p><p>This raise a problem that if an isla trace reads a register after having written to it, then this is ambiguous to represent.</p><p>Thus a partially monadic representation has been chosen:</p><ul><li>The effect of writes on registers are delayed to the end, which means that registers variable value in every expression is the value of that register at the beginning of the trace. In particular, if there are two write to the register, only the last one have any effect, the other can be deleted.</li><li>The memory operation behave in normal monadic way, in particular a memory read can read the value written by a previous write in the same instruction, even if this is very unlikely.</li></ul><p>In the end, both assertion and register write to different registers can be reordered at will.</p><p>TODO: To make it more clean, getting register writes and assertions out of the trace would make sense like:</p><pre><code class="ml">type mem_event = Read of ... | Write of ...
-type t = { asserts : exp list; reg_writes : (Reg.t * exp) list; mem: mem_event list }</code></pre><p>For all those reason, concatenating two trace semantically is very different that concatenating list of event, and is not implemented yet.</p><p>The important functions are <a href="index.html#val-of_isla"><code>of_isla</code></a> to convert and Isla traces and <a href="index.html#val-simplify"><code>simplify</code></a> for simplify traces.</p><nav class="toc"><ul><li><a href="#pretty-printing">Pretty printing</a></li><li><a href="#isla-to-trace-conversion">Isla to Trace conversion</a></li><li><a href="#trace-simplification">Trace simplification</a></li></ul></nav></header><dl><dt class="spec module" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span class="keyword">module</span> <a href="Var/index.html">Var</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module contains variable used in traces</p></dd></dl><dl><dt class="spec module" id="module-ExpPp"><a href="#module-ExpPp" class="anchor"></a><code><span class="keyword">module</span> ExpPp = <a href="../../Exp/index.html#module-Pp">Exp.Pp</a></code></dt><dd><p>A trace expression. No let bindings, no memory operations</p></dd></dl><div class="spec module" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span class="keyword">module</span> Typed = <a href="../../Exp/index.html#module-Typed">Exp.Typed</a></code></div><div class="spec module" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span class="keyword">module</span> <a href="Exp/index.html">Exp</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <a href="Exp/index.html#type-t">Exp.t</a></code></dt><dt class="spec type" id="type-event"><a href="#type-event" class="anchor"></a><code><span class="keyword">type</span> event</code><code> = </code><table class="variant"><tr id="type-event.WriteReg" class="anchored"><td class="def constructor"><a href="#type-event.WriteReg" class="anchor"></a><code>| </code><code><span class="constructor">WriteReg</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-event.reg" class="anchored"><td class="def field"><a href="#type-event.reg" class="anchor"></a><code>reg : <a href="../../State/Reg/index.html#type-t">State.Reg.t</a>;</code></td></tr><tr id="type-event.value" class="anchored"><td class="def field"><a href="#type-event.value" class="anchor"></a><code>value : <a href="index.html#type-exp">exp</a>;</code></td></tr></table><code>}</code></td></tr><tr id="type-event.ReadMem" class="anchored"><td class="def constructor"><a href="#type-event.ReadMem" class="anchor"></a><code>| </code><code><span class="constructor">ReadMem</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-event.addr" class="anchored"><td class="def field"><a href="#type-event.addr" class="anchor"></a><code>addr : <a href="index.html#type-exp">exp</a>;</code></td></tr><tr id="type-event.value" class="anchored"><td class="def field"><a href="#type-event.value" class="anchor"></a><code>value : int;</code></td></tr><tr id="type-event.size" class="anchored"><td class="def field"><a href="#type-event.size" class="anchor"></a><code>size : <a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a>;</code></td></tr></table><code>}</code></td></tr><tr id="type-event.WriteMem" class="anchored"><td class="def constructor"><a href="#type-event.WriteMem" class="anchor"></a><code>| </code><code><span class="constructor">WriteMem</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-event.addr" class="anchored"><td class="def field"><a href="#type-event.addr" class="anchor"></a><code>addr : <a href="index.html#type-exp">exp</a>;</code></td></tr><tr id="type-event.value" class="anchored"><td class="def field"><a href="#type-event.value" class="anchor"></a><code>value : <a href="index.html#type-exp">exp</a>;</code></td></tr><tr id="type-event.size" class="anchored"><td class="def field"><a href="#type-event.size" class="anchor"></a><code>size : <a href="../../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a>;</code></td></tr></table><code>}</code></td></tr><tr id="type-event.Assert" class="anchored"><td class="def constructor"><a href="#type-event.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <a href="index.html#type-exp">exp</a></code></td></tr></table></dt><dd><p>The event type. See the <a href="../index.html"><span>module description</span></a> for more details</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><a href="index.html#type-event">event</a> list</span></code></dt></dl><dl><dt class="spec value" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span class="keyword">val</span> iter_var : <span>(<a href="Exp/index.html#type-var">Exp.var</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> unit</code></dt></dl><section><header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2></header><dl><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span><span>(<span class="type-var">'a</span>, <a href="Var/index.html#type-t">Var.t</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print an expression</p></dd></dl><dl><dt class="spec value" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span class="keyword">val</span> pp_event : <a href="index.html#type-event">event</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print an event</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty print a trace</p></dd></dl></section><section><header><h2 id="isla-to-trace-conversion"><a href="#isla-to-trace-conversion" class="anchor"></a>Isla to Trace conversion</h2><p>This section perform the conversion from Isla trace to the traces of this module.</p><p>The conversion is generrally obvious, however there is subtlety: If the Isla trace reads a register after having written it, then the read produce the written expression instead of just the symbolic value of that register. That why there is a <code>written_registers</code> parameter to some function of this section.</p></header><dl><dt class="spec exception" id="exception-OfIslaError"><a href="#exception-OfIslaError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">OfIslaError</span></code></dt><dd><p>Throw an error in case of local conversion error. Normally a type-checked Isla trace should not fail in this section</p></dd></dl><dl><dt class="spec type" id="type-value_context"><a href="#type-value_context" class="anchor"></a><code><span class="keyword">type</span> value_context</code><code> = <span><a href="index.html#type-exp">exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></code></dt><dd><p>The context mapping Isla variable numbers to trace expression</p></dd></dl><dl><dt class="spec value" id="val-get_var"><a href="#val-get_var" class="anchor"></a><code><span class="keyword">val</span> get_var : <span><span class="type-var">'a</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the exression of the variable at the index. Throw <a href="index.html#exception-OfIslaError"><code>OfIslaError</code></a> if the variable is not bound</p></dd></dl><dl><dt class="spec value" id="val-exp_conv_subst"><a href="#val-exp_conv_subst" class="anchor"></a><code><span class="keyword">val</span> exp_conv_subst : <a href="index.html#type-value_context">value_context</a> <span>&#45;&gt;</span> <a href="../../Isla/index.html#type-rexp">Isla.rexp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Convert an Isla expression to a <code>Trace</code> expression by replacing all Isla variable by their value in the context. Throw <a href="index.html#exception-OfIslaError"><code>OfIslaError</code></a> if the substitution fails</p></dd></dl><dl><dt class="spec value" id="val-exp_of_valu"><a href="#val-exp_of_valu" class="anchor"></a><code><span class="keyword">val</span> exp_of_valu : Isla_lang.AST.lrng <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../../Isla/index.html">Isla</a>.valu <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Convert an <span class="xref-unresolved" title="unresolved reference to &quot;Isla.valu&quot;"><a href="../../Isla/index.html"><code>Isla</code></a>.valu</span> in a expression</p></dd></dl><dl><dt class="spec value" id="val-write_to_valu"><a href="#val-write_to_valu" class="anchor"></a><code><span class="keyword">val</span> write_to_valu : <span><span class="type-var">'a</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../../Isla/index.html">Isla</a>.valu <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write an expression to an <span class="xref-unresolved" title="unresolved reference to &quot;Isla.valu&quot;"><a href="../../Isla/index.html"><code>Isla</code></a>.valu</span></p></dd></dl><dl><dt class="spec value" id="val-event_of_isla"><a href="#val-event_of_isla" class="anchor"></a><code><span class="keyword">val</span> event_of_isla : <span>written_registers:<span><span>(<a href="../../State/Reg/index.html#type-t">State.Reg.t</a>, <a href="index.html#type-exp">exp</a>)</span> Stdlib.Hashtbl.t</span></span> <span>&#45;&gt;</span> <span>read_counter:<a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span> <span>&#45;&gt;</span> <span>vc:<a href="index.html#type-value_context">value_context</a></span> <span>&#45;&gt;</span> <a href="../../Isla/index.html#type-revent">Isla.revent</a> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> option</span></code></dt><dd><p>Convert an isla event to optionally a Trace event, most events are deleted</p></dd></dl><dl><dt class="spec value" id="val-of_isla"><a href="#val-of_isla" class="anchor"></a><code><span class="keyword">val</span> of_isla : <a href="../../Isla/index.html#type-rtrc">Isla.rtrc</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Top level function to convert an isla trace to one of this module</p></dd></dl></section><section><header><h2 id="trace-simplification"><a href="#trace-simplification" class="anchor"></a>Trace simplification</h2></header><dl><dt class="spec module" id="module-SimpContext"><a href="#module-SimpContext" class="anchor"></a><code><span class="keyword">module</span> <a href="SimpContext/index.html">SimpContext</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>A instance of <a href="../../Z3/ContextCounter/index.html"><code>Z3.ContextCounter</code></a>.</p></dd></dl><div class="spec module" id="module-Z3Tr"><a href="#module-Z3Tr" class="anchor"></a><code><span class="keyword">module</span> <a href="Z3Tr/index.html">Z3Tr</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-VarTbl"><a href="#module-VarTbl" class="anchor"></a><code><span class="keyword">module</span> <a href="VarTbl/index.html">VarTbl</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-declare_non_det"><a href="#val-declare_non_det" class="anchor"></a><code><span class="keyword">val</span> declare_non_det : <a href="../../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> list</span></code></dt><dd><p>Simplify a trace by using Z3. Perform both local expression simplification and global assertion removal (when an assertion is always true)</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Base (read-dwarf.Trace.Base)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Base</nav><header class="odoc-preamble"><h1>Module <code><span>Trace.Base</span></code></h1><p>This module defines a new simplified kind of trace to replace Isla traces in the later stages of the instruction semantics processing.</p><p>The traces are even simpler and more easily typable. The possible events are in the type <a href="#type-event"><code>event</code></a> and traces (<a href="#type-t"><code>t</code></a>) are just list of them.</p><p>Compared to Isla, the concept of reading a register do not exist anymore. Nor the concept of pure symbolic variable or Sail structured values. Instead expression can contain only registers and results of previous memory read as decribe in the type <a href="Var/index.html#type-t"><code>Var.t</code></a>. All writing event directly write an entire expression. There are no intermediary variable definitions.</p><p>This raise a problem that if an isla trace reads a register after having written to it, then this is ambiguous to represent.</p><p>Thus a partially monadic representation has been chosen:</p><ul><li>The effect of writes on registers are delayed to the end, which means that registers variable value in every expression is the value of that register at the beginning of the trace. In particular, if there are two write to the register, only the last one have any effect, the other can be deleted.</li><li>The memory operation behave in normal monadic way, in particular a memory read can read the value written by a previous write in the same instruction, even if this is very unlikely.</li></ul><p>In the end, both assertion and register write to different registers can be reordered at will.</p><p>TODO: To make it more clean, getting register writes and assertions out of the trace would make sense like:</p><pre class="language-ocaml"><code>type mem_event = Read of ... | Write of ...
+type t = { asserts : exp list; reg_writes : (Reg.t * exp) list; mem: mem_event list }</code></pre><p>For all those reason, concatenating two trace semantically is very different that concatenating list of event, and is not implemented yet.</p><p>The important functions are <a href="#val-of_isla"><code>of_isla</code></a> to convert and Isla traces and <a href="#val-simplify"><code>simplify</code></a> for simplify traces.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#pretty-printing">Pretty printing</a></li><li><a href="#isla-to-trace-conversion">Isla to Trace conversion</a></li><li><a href="#trace-simplification">Trace simplification</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Var/index.html">Var</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module contains variable used in traces</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ExpPp"><a href="#module-ExpPp" class="anchor"></a><code><span><span class="keyword">module</span> ExpPp</span><span> = <a href="../../Exp/PpExp/index.html">Exp.Pp</a></span></code></div><div class="spec-doc"><p>A trace expression. No let bindings, no memory operations</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span><span class="keyword">module</span> Typed</span><span> = <a href="../../Exp/Typed/index.html">Exp.Typed</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Exp/index.html">Exp</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <a href="Exp/index.html#type-t">Exp.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-event"><a href="#type-event" class="anchor"></a><code><span><span class="keyword">type</span> event</span><span> = </span></code><ol><li id="type-event.WriteReg" class="def variant constructor anchored"><a href="#type-event.WriteReg" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteReg</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-event.reg" class="def record field anchored"><a href="#type-event.reg" class="anchor"></a><code><span>reg : <a href="../../State/Reg/index.html#type-t">State.Reg.t</a>;</span></code></li><li id="type-event.value" class="def record field anchored"><a href="#type-event.value" class="anchor"></a><code><span>value : <a href="#type-exp">exp</a>;</span></code></li></ol><code><span>}</span></code></li><li id="type-event.ReadMem" class="def variant constructor anchored"><a href="#type-event.ReadMem" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadMem</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-event.addr" class="def record field anchored"><a href="#type-event.addr" class="anchor"></a><code><span>addr : <a href="#type-exp">exp</a>;</span></code></li><li id="type-event.value" class="def record field anchored"><a href="#type-event.value" class="anchor"></a><code><span>value : int;</span></code></li><li id="type-event.size" class="def record field anchored"><a href="#type-event.size" class="anchor"></a><code><span>size : <a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a>;</span></code></li></ol><code><span>}</span></code></li><li id="type-event.WriteMem" class="def variant constructor anchored"><a href="#type-event.WriteMem" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteMem</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-event.addr" class="def record field anchored"><a href="#type-event.addr" class="anchor"></a><code><span>addr : <a href="#type-exp">exp</a>;</span></code></li><li id="type-event.value" class="def record field anchored"><a href="#type-event.value" class="anchor"></a><code><span>value : <a href="#type-exp">exp</a>;</span></code></li><li id="type-event.size" class="def record field anchored"><a href="#type-event.size" class="anchor"></a><code><span>size : <a href="../../Ast/Base/Size/index.html#type-t">Ast.Size.t</a>;</span></code></li></ol><code><span>}</span></code></li><li id="type-event.Assert" class="def variant constructor anchored"><a href="#type-event.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <a href="#type-exp">exp</a></span></code></li></ol></div><div class="spec-doc"><p>The event type. See the <a href="../index.html" title="Trace">module description</a> for more details</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><a href="#type-event">event</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span><span class="keyword">val</span> iter_var : <span><span>(<span><a href="Exp/index.html#type-var">Exp.var</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : <span><span><span>(<span class="type-var">'a</span>, <a href="Var/index.html#type-t">Var.t</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print an expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span><span class="keyword">val</span> pp_event : <span><a href="#type-event">event</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print an event</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a trace</p></div></div><h2 id="isla-to-trace-conversion"><a href="#isla-to-trace-conversion" class="anchor"></a>Isla to Trace conversion</h2><p>This section perform the conversion from Isla trace to the traces of this module.</p><p>The conversion is generrally obvious, however there is subtlety: If the Isla trace reads a register after having written it, then the read produce the written expression instead of just the symbolic value of that register. That why there is a <code>written_registers</code> parameter to some function of this section.</p><div class="odoc-spec"><div class="spec exception anchored" id="exception-OfIslaError"><a href="#exception-OfIslaError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">OfIslaError</span></span></code></div><div class="spec-doc"><p>Throw an error in case of local conversion error. Normally a type-checked Isla trace should not fail in this section</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value_context"><a href="#type-value_context" class="anchor"></a><code><span><span class="keyword">type</span> value_context</span><span> = <span><a href="#type-exp">exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span></code></div><div class="spec-doc"><p>The context mapping Isla variable numbers to trace expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_var"><a href="#val-get_var" class="anchor"></a><code><span><span class="keyword">val</span> get_var : <span><span><span class="type-var">'a</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the exression of the variable at the index. Throw <a href="#exception-OfIslaError"><code>OfIslaError</code></a> if the variable is not bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_conv_subst"><a href="#val-exp_conv_subst" class="anchor"></a><code><span><span class="keyword">val</span> exp_conv_subst : <span><a href="#type-value_context">value_context</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Isla/index.html#type-rexp">Isla.rexp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Convert an Isla expression to a <code>Trace</code> expression by replacing all Isla variable by their value in the context. Throw <a href="#exception-OfIslaError"><code>OfIslaError</code></a> if the substitution fails</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_of_valu"><a href="#val-exp_of_valu" class="anchor"></a><code><span><span class="keyword">val</span> exp_of_valu : 
+  <span><span class="xref-unresolved">Isla_lang</span>.AST.lrng <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-exp">exp</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Isla/index.html#type-valu">Isla.valu</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Convert an <a href="../../Isla/index.html#type-valu"><code>Isla.valu</code></a> in a expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_to_valu"><a href="#val-write_to_valu" class="anchor"></a><code><span><span class="keyword">val</span> write_to_valu : <span><span><span class="type-var">'a</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Isla/index.html#type-valu">Isla.valu</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Write an expression to an <a href="../../Isla/index.html#type-valu"><code>Isla.valu</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-events_of_isla"><a href="#val-events_of_isla" class="anchor"></a><code><span><span class="keyword">val</span> events_of_isla : 
+  <span><span class="label">segments_map</span>:<span><span>(string * int)</span> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">written_registers</span>:<span><span>(<a href="../../State/Reg/index.html#type-t">State.Reg.t</a>, <a href="#type-exp">exp</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">read_counter</span>:<a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">vc</span>:<a href="#type-value_context">value_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../Isla/index.html#type-revent">Isla.revent</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-event">event</a> list</span></span></code></div><div class="spec-doc"><p>Convert an isla event to Trace events, most events are deleted</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_isla"><a href="#val-of_isla" class="anchor"></a><code><span><span class="keyword">val</span> of_isla : <span><span><a href="../../Isla/index.html#type-segment">Isla.segment</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../Isla/index.html#type-rtrc">Isla.rtrc</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Top level function to convert an isla trace to one of this module</p></div></div><h2 id="trace-simplification"><a href="#trace-simplification" class="anchor"></a>Trace simplification</h2><div class="odoc-spec"><div class="spec module anchored" id="module-SimpContext"><a href="#module-SimpContext" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SimpContext/index.html">SimpContext</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A instance of <a href="../../Z3/ContextCounter/index.html"><code>Z3.ContextCounter</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Z3Tr"><a href="#module-Z3Tr" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Z3Tr/index.html">Z3Tr</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-VarTbl"><a href="#module-VarTbl" class="anchor"></a><code><span><span class="keyword">module</span> <a href="VarTbl/index.html">VarTbl</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_non_det"><a href="#val-declare_non_det" class="anchor"></a><code><span><span class="keyword">val</span> declare_non_det : <span><a href="../../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-event">event</a> list</span></span></code></div><div class="spec-doc"><p>Simplify a trace by using Z3. Perform both local expression simplification and global assertion removal (when an assertion is always true)</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Cache/TC/index.html b/doc/html/read-dwarf/Trace/Cache/TC/index.html
index 8355a0cb..fcda26c6 100644
--- a/doc/html/read-dwarf/Trace/Cache/TC/index.html
+++ b/doc/html/read-dwarf/Trace/Cache/TC/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TC (read-dwarf.Trace.Cache.TC)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; TC</nav><h1>Module <code>Cache.TC</code></h1></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../../../Isla__Cache/Opcode/index.html#type-t">Opcode.t</a></code></dt><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code><code> = <a href="../Traces/index.html#type-t">Traces.t</a></code></dt><dt class="spec type" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span class="keyword">type</span> epoch</code><code> = <a href="../../../Isla__Cache/Epoch/index.html#type-t">Epoch.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../Utils__Cache/Make/index.html#type-t">Utils__Cache.Make(Opcode)(Traces)(Epoch).t</a></code></dt></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-epoch">epoch</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TC (read-dwarf.Trace.Cache.TC)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; TC</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.TC</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../../../Isla/Cache/Opcode/index.html#type-t">Opcode.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span><span> = <a href="../Traces/index.html#type-t">Traces.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span><span class="keyword">type</span> epoch</span><span> = <a href="../../../Isla/Cache/Epoch/index.html#type-t">Epoch.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-epoch">epoch</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Cache/Traces/index.html b/doc/html/read-dwarf/Trace/Cache/Traces/index.html
index a9011efd..c7183ba7 100644
--- a/doc/html/read-dwarf/Trace/Cache/Traces/index.html
+++ b/doc/html/read-dwarf/Trace/Cache/Traces/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Traces (read-dwarf.Trace.Cache.Traces)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Traces</nav><h1>Module <code>Cache.Traces</code></h1><p>Store element of type <a href="../../Base/index.html#type-t"><code>Base.t</code></a><code>list</code> on disk.</p><p>First a hashmap from register numbers to path and type is stored. Then the actual tracelist is marshaled.</p><p>When loading the register numbering may be different, and some may not exist. So we create all missing register, then we replace the old number with the new ones.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><a href="../../Base/index.html#type-t">Base.t</a> list</span></code></dt></dl><div class="spec module" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span class="keyword">module</span> Reg = <a href="../../../State/index.html#module-Reg">State.Reg</a></code></div><dl><dt class="spec type" id="type-regs"><a href="#type-regs" class="anchor"></a><code><span class="keyword">type</span> regs</code><code> = <span><span>(<a href="../../../State/Reg/index.html#type-t">Reg.t</a>, <a href="../../../State__Reg/Path/index.html#type-t">Reg.Path.t</a> * <a href="../../../State/Reg/index.html#type-ty">Reg.ty</a>)</span> Stdlib.Hashtbl.t</span></code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Traces (read-dwarf.Trace.Cache.Traces)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Trace</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Traces</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.Traces</span></code></h1><p>Store element of type <a href="../../Base/index.html#type-t"><code>Base.t</code></a><code>list</code> on disk.</p><p>First a hashmap from register numbers to path and type is stored. Then the actual tracelist is marshaled.</p><p>When loading the register numbering may be different, and some may not exist. So we create all missing register, then we replace the old number with the new ones.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><a href="../../Base/index.html#type-t">Base.t</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span><span class="keyword">module</span> Reg</span><span> = <a href="../../../State/Reg/index.html">State.Reg</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-regs"><a href="#type-regs" class="anchor"></a><code><span><span class="keyword">type</span> regs</span><span> = <span><span>(<a href="../../../State/Reg/index.html#type-t">Reg.t</a>, <a href="../../../State/Reg/Path/index.html#type-t">Reg.Path.t</a> * <a href="../../../State/Reg/index.html#type-ty">Reg.ty</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Cache/index.html b/doc/html/read-dwarf/Trace/Cache/index.html
index 06e7a6e4..fdec7ca1 100644
--- a/doc/html/read-dwarf/Trace/Cache/index.html
+++ b/doc/html/read-dwarf/Trace/Cache/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Trace.Cache)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Cache</nav><h1>Module <code>Trace.Cache</code></h1><p>This module provides a caching system for fully processed traces</p><p>The top level function to get traces from an opcode is <a href="index.html#val-get_traces"><code>get_traces</code></a>. This is the function called by the <span class="xref-unresolved" title="unresolved reference to &quot;Run.Runner&quot;"><a href="../index.html#module-Run"><code>Run</code></a>.Runner</span>.</p></header><div class="spec module" id="module-Opcode"><a href="#module-Opcode" class="anchor"></a><code><span class="keyword">module</span> Opcode = <a href="../../Isla/Cache/index.html#module-Opcode">Isla.Cache.Opcode</a></code></div><div class="spec module" id="module-Epoch"><a href="#module-Epoch" class="anchor"></a><code><span class="keyword">module</span> Epoch = <a href="../../Isla/Cache/index.html#module-Epoch">Isla.Cache.Epoch</a></code></div><dl><dt class="spec module" id="module-Traces"><a href="#module-Traces" class="anchor"></a><code><span class="keyword">module</span> <a href="Traces/index.html">Traces</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Store element of type <a href="../Base/index.html#type-t"><code>Base.t</code></a><code>list</code> on disk.</p></dd></dl><div class="spec module" id="module-TC"><a href="#module-TC" class="anchor"></a><code><span class="keyword">module</span> <a href="TC/index.html">TC</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-cache"><a href="#val-cache" class="anchor"></a><code><span class="keyword">val</span> cache : <span><span><a href="TC/index.html#type-t">TC.t</a> option</span> Stdlib.ref</span></code></dt></dl><dl><dt class="spec type" id="type-config"><a href="#type-config" class="anchor"></a><code><span class="keyword">type</span> config</code><code> = <a href="../../Isla/Cache/index.html#type-config">Isla.Cache.config</a></code></dt></dl><dl><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : <a href="../../Isla/Cache/index.html#type-config">Isla.Cache.config</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Start the caching system. Start <a href="../../Isla/Cache/index.html"><code>Isla.Cache</code></a> too</p></dd></dl><dl><dt class="spec value" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span class="keyword">val</span> stop : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop the caching system</p></dd></dl><dl><dt class="spec value" id="val-get_cache"><a href="#val-get_cache" class="anchor"></a><code><span class="keyword">val</span> get_cache : unit <span>&#45;&gt;</span> <a href="TC/index.html#type-t">TC.t</a></code></dt><dd><p>Get the cache and fails if the cache wasn't started</p></dd></dl><dl><dt class="spec value" id="val-get_traces"><a href="#val-get_traces" class="anchor"></a><code><span class="keyword">val</span> get_traces : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Base/index.html#type-t">Base.t</a> list</span></code></dt><dd><p>Get the traces of the opcode given. Use <a href="../../Isla/Server/index.html"><code>Isla.Server</code></a> if the value is not in the cache</p></dd></dl><dl><dt class="spec value" id="val-get_instr"><a href="#val-get_instr" class="anchor"></a><code><span class="keyword">val</span> get_instr : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <a href="../Instr/index.html#type-t">Instr.t</a></code></dt><dd><p>Get a full blown <a href="../Instr/index.html"><code>Instr</code></a> from the opcode, going through the whole Isla pipeline if necessary.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Trace.Cache)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Cache</nav><header class="odoc-preamble"><h1>Module <code><span>Trace.Cache</span></code></h1><p>This module provides a caching system for fully processed traces</p><p>The top level function to get traces from an opcode is <a href="#val-get_traces"><code>get_traces</code></a>. This is the function called by the <code>Run.Runner</code>.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Opcode"><a href="#module-Opcode" class="anchor"></a><code><span><span class="keyword">module</span> Opcode</span><span> = <a href="../../Isla/Cache/Opcode/index.html">Isla.Cache.Opcode</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Epoch"><a href="#module-Epoch" class="anchor"></a><code><span><span class="keyword">module</span> Epoch</span><span> = <a href="../../Isla/Cache/Epoch/index.html">Isla.Cache.Epoch</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Traces"><a href="#module-Traces" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Traces/index.html">Traces</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Store element of type <a href="../Base/index.html#type-t"><code>Base.t</code></a><code>list</code> on disk.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-TC"><a href="#module-TC" class="anchor"></a><code><span><span class="keyword">module</span> <a href="TC/index.html">TC</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cache"><a href="#val-cache" class="anchor"></a><code><span><span class="keyword">val</span> cache : <span><span><a href="TC/index.html#type-t">TC.t</a> option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-config"><a href="#type-config" class="anchor"></a><code><span><span class="keyword">type</span> config</span><span> = <a href="../../Isla/Cache/index.html#type-config">Isla.Cache.config</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span><a href="../../Isla/Cache/index.html#type-config">Isla.Cache.config</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start the caching system. Start <a href="../../Isla/Cache/index.html"><code>Isla.Cache</code></a> too</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span><span class="keyword">val</span> stop : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop the caching system</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_cache"><a href="#val-get_cache" class="anchor"></a><code><span><span class="keyword">val</span> get_cache : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="TC/index.html#type-t">TC.t</a></span></code></div><div class="spec-doc"><p>Get the cache and fails if the cache wasn't started</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_traces"><a href="#val-get_traces" class="anchor"></a><code><span><span class="keyword">val</span> get_traces : <span><a href="../../Isla/Server/index.html#type-opcode">Isla.Server.opcode</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-t">Base.t</a> list</span></span></code></div><div class="spec-doc"><p>Get the traces of the opcode given. Use <a href="../../Isla/Server/index.html"><code>Isla.Server</code></a> if the value is not in the cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_instr"><a href="#val-get_instr" class="anchor"></a><code><span><span class="keyword">val</span> get_instr : <span><span>(<a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span><a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Instr/index.html#type-t">Instr.t</a></span></code></div><div class="spec-doc"><p>Get a full blown <a href="../Instr/index.html"><code>Instr</code></a> from the opcode, going through the whole Isla pipeline if necessary.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Context/index.html b/doc/html/read-dwarf/Trace/Context/index.html
index 856d32fa..2188bb5a 100644
--- a/doc/html/read-dwarf/Trace/Context/index.html
+++ b/doc/html/read-dwarf/Trace/Context/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Context (read-dwarf.Trace.Context)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Context</nav><h1>Module <code>Trace.Context</code></h1><p>This module provide the type for a context to run a trace</p><p>Any information that should be required to run a trace but is not part of the state itself should be added here</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.reg_writes" class="anchored"><td class="def field"><a href="#type-t.reg_writes" class="anchor"></a><code>reg_writes : <span><span>(<a href="../../State/Reg/index.html#type-t">State.Reg.t</a> * <a href="../../State/index.html#type-tval">State.tval</a>)</span> <a href="../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</code></td><td class="doc"><p>Stores the delayed register writes</p></td></tr><tr id="type-t.mem_reads" class="anchored"><td class="def field"><a href="#type-t.mem_reads" class="anchor"></a><code>mem_reads : <span><a href="../../State/index.html#type-tval">State.tval</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span>;</code></td><td class="doc"><p>Stores the result of memory reads</p></td></tr><tr id="type-t.state" class="anchored"><td class="def field"><a href="#type-t.state" class="anchor"></a><code>state : <a href="../../State/index.html#type-t">State.t</a>;</code></td></tr><tr id="type-t.dwarf" class="anchored"><td class="def field"><a href="#type-t.dwarf" class="anchor"></a><code>dwarf : <span><a href="../../Dw/index.html#type-t">Dw.t</a> option</span>;</code></td><td class="doc"><p>Optionally DWARF information. If present, typing is enabled</p></td></tr></table><code>}</code></dt><dd><p>The context to run a trace</p></dd></dl><dl><dt class="spec value" id="val-make_context"><a href="#val-make_context" class="anchor"></a><code><span class="keyword">val</span> make_context : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a <code>context</code> from a state</p></dd></dl><dl><dt class="spec value" id="val-expand_var"><a href="#val-expand_var" class="anchor"></a><code><span class="keyword">val</span> expand_var : <span>ctxt:<a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../Base/Var/index.html#type-t">Base.Var.t</a> <span>&#45;&gt;</span> <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-exp">State.exp</a></code></dt><dd><p>Expand a Trace variable to a State expression, using the context</p></dd></dl><dl><dt class="spec value" id="val-map_var"><a href="#val-map_var" class="anchor"></a><code><span class="keyword">val</span> map_var : <span>ctxt:<a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../Base/Var/index.html#type-t">Base.Var.t</a> <span>&#45;&gt;</span> <span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-var">State.var</a></code></dt><dt class="spec value" id="val-typing_enabled"><a href="#val-typing_enabled" class="anchor"></a><code><span class="keyword">val</span> typing_enabled : <span>ctxt:<a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if typing should enabled with this context</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Context (read-dwarf.Trace.Context)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Context</nav><header class="odoc-preamble"><h1>Module <code><span>Trace.Context</span></code></h1><p>This module provide the type for a context to run a trace</p><p>Any information that should be required to run a trace but is not part of the state itself should be added here</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-SMap"><a href="#module-SMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SMap/index.html">SMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.reg_writes" class="def record field anchored"><a href="#type-t.reg_writes" class="anchor"></a><code><span>reg_writes : <span><span>(<a href="../../State/Reg/index.html#type-t">State.Reg.t</a> * <a href="../../State/index.html#type-tval">State.tval</a>)</span> <a href="../../Utils/Vec/index.html#type-t">Utils.Vec.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Stores the delayed register writes</p><span class="comment-delim">*)</span></div></li><li id="type-t.mem_reads" class="def record field anchored"><a href="#type-t.mem_reads" class="anchor"></a><code><span>mem_reads : <span><a href="../../State/index.html#type-tval">State.tval</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Stores the result of memory reads</p><span class="comment-delim">*)</span></div></li><li id="type-t.nondets" class="def record field anchored"><a href="#type-t.nondets" class="anchor"></a><code><span>nondets : <span><a href="../../State/index.html#type-var">State.var</a> <a href="../../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Stores the mapping of nondet variables</p><span class="comment-delim">*)</span></div></li><li id="type-t.state" class="def record field anchored"><a href="#type-t.state" class="anchor"></a><code><span>state : <a href="../../State/index.html#type-t">State.t</a>;</span></code></li><li id="type-t.segments" class="def record field anchored"><a href="#type-t.segments" class="anchor"></a><code><span>segments : <span><a href="../../State/index.html#type-exp">State.exp</a> <a href="SMap/index.html#type-t">SMap.t</a></span>;</span></code></li><li id="type-t.asserts" class="def record field anchored"><a href="#type-t.asserts" class="anchor"></a><code><span>asserts : <span><a href="../../State/index.html#type-exp">State.exp</a> list</span>;</span></code></li><li id="type-t.dwarf" class="def record field anchored"><a href="#type-t.dwarf" class="anchor"></a><code><span>dwarf : <span><a href="../../Dw/index.html#type-t">Dw.t</a> option</span>;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Optionally DWARF information. If present, typing is enabled</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The context to run a trace</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make_context"><a href="#val-make_context" class="anchor"></a><code><span><span class="keyword">val</span> make_context : 
+  <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?relocation</span>:<a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a <code>context</code> from a state</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expand_var"><a href="#val-expand_var" class="anchor"></a><code><span><span class="keyword">val</span> expand_var : <span><span class="label">ctxt</span>:<a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/Var/index.html#type-t">Base.Var.t</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="../../Ast/index.html#type-no">Ast.no</a> <a href="../../Ast/index.html#type-ty">Ast.ty</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-exp">State.exp</a></span></code></div><div class="spec-doc"><p>Expand a Trace variable to a State expression, using the context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-typing_enabled"><a href="#val-typing_enabled" class="anchor"></a><code><span><span class="keyword">val</span> typing_enabled : <span><span class="label">ctxt</span>:<a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if typing should enabled with this context</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Z3St"><a href="#module-Z3St" class="anchor"></a><code><span><span class="keyword">module</span> Z3St</span><span> = <a href="../../State/Simplify/Z3St/index.html">State.Simplify.Z3St</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><span class="label">ctxt</span>:<a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/index.html#type-exp">State.exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-exp">State.exp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Instr/index.html b/doc/html/read-dwarf/Trace/Instr/index.html
index 51bd4a64..52634f13 100644
--- a/doc/html/read-dwarf/Trace/Instr/index.html
+++ b/doc/html/read-dwarf/Trace/Instr/index.html
@@ -1,2 +1,5 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Instr (read-dwarf.Trace.Instr)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Instr</nav><h1>Module <code>Trace.Instr</code></h1><p>This module provide the representation of an instruction. It only contains generic information about the opcode and not specific information about a place in the code.</p></header><div class="spec module" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span class="keyword">module</span> Reg = <a href="../../State/index.html#module-Reg">State.Reg</a></code></div><dl><dt class="spec type" id="type-trace_meta"><a href="#type-trace_meta" class="anchor"></a><code><span class="keyword">type</span> trace_meta</code><code> = </code><code>{</code><table class="record"><tr id="type-trace_meta.trace" class="anchored"><td class="def field"><a href="#type-trace_meta.trace" class="anchor"></a><code>trace : <a href="../Base/index.html#type-t">Base.t</a>;</code></td></tr><tr id="type-trace_meta.jump_target" class="anchored"><td class="def field"><a href="#type-trace_meta.jump_target" class="anchor"></a><code>jump_target : <span><a href="../Base/index.html#type-exp">Base.exp</a> option</span>;</code></td></tr><tr id="type-trace_meta.read" class="anchored"><td class="def field"><a href="#type-trace_meta.read" class="anchor"></a><code>read : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</code></td></tr><tr id="type-trace_meta.written" class="anchored"><td class="def field"><a href="#type-trace_meta.written" class="anchor"></a><code>written : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</code></td></tr></table><code>}</code></dt><dd><p>A simple trace with its metadata</p><p>If there is a <code>WriteReg {reg;value}</code> event in <code>trace</code> where <code>reg = Arch.pc ()</code>, <code>jump = Some value</code>, otherwise it is <code>None</code>. If there are multiple such events, it will store the value of the last one.</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.traces" class="anchored"><td class="def field"><a href="#type-t.traces" class="anchor"></a><code>traces : <span><a href="index.html#type-trace_meta">trace_meta</a> list</span>;</code></td></tr><tr id="type-t.length" class="anchored"><td class="def field"><a href="#type-t.length" class="anchor"></a><code>length : int;</code></td><td class="doc"><p>Bytes length</p></td></tr><tr id="type-t.read" class="anchored"><td class="def field"><a href="#type-t.read" class="anchor"></a><code>read : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</code></td></tr><tr id="type-t.written" class="anchored"><td class="def field"><a href="#type-t.written" class="anchor"></a><code>written : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</code></td></tr><tr id="type-t.opcode" class="anchored"><td class="def field"><a href="#type-t.opcode" class="anchor"></a><code>opcode : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a>;</code></td></tr></table><code>}</code></dt><dd><p>A full instruction representation</p></dd></dl><dl><dt class="spec value" id="val-dedup_regs"><a href="#val-dedup_regs" class="anchor"></a><code><span class="keyword">val</span> dedup_regs : <span><a href="../../State/Reg/index.html#type-t">State.Reg.t</a> list</span> <span>&#45;&gt;</span> <span><a href="../../State/Reg/index.html#type-t">State.Reg.t</a> list</span></code></dt><dt class="spec value" id="val-footprint"><a href="#val-footprint" class="anchor"></a><code><span class="keyword">val</span> footprint : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="../../State/Reg/index.html#type-t">State.Reg.t</a> list</span></code></dt><dt class="spec value" id="val-trace_meta_of_trace"><a href="#val-trace_meta_of_trace" class="anchor"></a><code><span class="keyword">val</span> trace_meta_of_trace : <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> <a href="index.html#type-trace_meta">trace_meta</a></code></dt><dd><p>Compute the metadata of trace</p></dd></dl><dl><dt class="spec value" id="val-of_traces"><a href="#val-of_traces" class="anchor"></a><code><span class="keyword">val</span> of_traces : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> <span>&#45;&gt;</span> <span><a href="../Base/index.html#type-t">Base.t</a> list</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Generate full instruction data from a list of traces</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print the representation of an instruction</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Instr (read-dwarf.Trace.Instr)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Instr</nav><header class="odoc-preamble"><h1>Module <code><span>Trace.Instr</span></code></h1><p>This module provide the representation of an instruction. It only contains generic information about the opcode and not specific information about a place in the code.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Reg"><a href="#module-Reg" class="anchor"></a><code><span><span class="keyword">module</span> Reg</span><span> = <a href="../../State/Reg/index.html">State.Reg</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-trace_meta"><a href="#type-trace_meta" class="anchor"></a><code><span><span class="keyword">type</span> trace_meta</span><span> = </span><span>{</span></code><ol><li id="type-trace_meta.trace" class="def record field anchored"><a href="#type-trace_meta.trace" class="anchor"></a><code><span>trace : <a href="../Base/index.html#type-t">Base.t</a>;</span></code></li><li id="type-trace_meta.jump_target" class="def record field anchored"><a href="#type-trace_meta.jump_target" class="anchor"></a><code><span>jump_target : <span><a href="../Base/index.html#type-exp">Base.exp</a> option</span>;</span></code></li><li id="type-trace_meta.read" class="def record field anchored"><a href="#type-trace_meta.read" class="anchor"></a><code><span>read : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</span></code></li><li id="type-trace_meta.written" class="def record field anchored"><a href="#type-trace_meta.written" class="anchor"></a><code><span>written : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>A simple trace with its metadata</p><p>If there is a <code>WriteReg {reg;value}</code> event in <code>trace</code> where <code>reg = Arch.pc ()</code>, <code>jump = Some value</code>, otherwise it is <code>None</code>. If there are multiple such events, it will store the value of the last one.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SMap"><a href="#module-SMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SMap/index.html">SMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.traces" class="def record field anchored"><a href="#type-t.traces" class="anchor"></a><code><span>traces : <span><a href="#type-trace_meta">trace_meta</a> list</span>;</span></code></li><li id="type-t.length" class="def record field anchored"><a href="#type-t.length" class="anchor"></a><code><span>length : int;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Bytes length</p><span class="comment-delim">*)</span></div></li><li id="type-t.read" class="def record field anchored"><a href="#type-t.read" class="anchor"></a><code><span>read : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</span></code></li><li id="type-t.written" class="def record field anchored"><a href="#type-t.written" class="anchor"></a><code><span>written : <span><a href="../../State/Reg/index.html#type-t">Reg.t</a> list</span>;</span></code></li><li id="type-t.opcode" class="def record field anchored"><a href="#type-t.opcode" class="anchor"></a><code><span>opcode : <a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a>;</span></code></li><li id="type-t.relocation" class="def record field anchored"><a href="#type-t.relocation" class="anchor"></a><code><span>relocation : <span><a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> option</span>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>A full instruction representation</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dedup_regs"><a href="#val-dedup_regs" class="anchor"></a><code><span><span class="keyword">val</span> dedup_regs : <span><span><a href="../../State/Reg/index.html#type-t">State.Reg.t</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/Reg/index.html#type-t">State.Reg.t</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-footprint"><a href="#val-footprint" class="anchor"></a><code><span><span class="keyword">val</span> footprint : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../../State/Reg/index.html#type-t">State.Reg.t</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trace_meta_of_trace"><a href="#val-trace_meta_of_trace" class="anchor"></a><code><span><span class="keyword">val</span> trace_meta_of_trace : <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-trace_meta">trace_meta</a></span></code></div><div class="spec-doc"><p>Compute the metadata of trace</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_traces"><a href="#val-of_traces" class="anchor"></a><code><span><span class="keyword">val</span> of_traces : 
+  <span><span>(<a href="../../Utils/BytesSeq/index.html#type-t">Utils.BytesSeq.t</a> * <span><a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> option</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="../Base/index.html#type-t">Base.t</a> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Generate full instruction data from a list of traces</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print the representation of an instruction</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/Run/index.html b/doc/html/read-dwarf/Trace/Run/index.html
index 4da88007..2b54366d 100644
--- a/doc/html/read-dwarf/Trace/Run/index.html
+++ b/doc/html/read-dwarf/Trace/Run/index.html
@@ -1,2 +1,18 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Run (read-dwarf.Trace.Run)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Run</nav><h1>Module <code>Trace.Run</code></h1><p>This module is for running trace from <a href="../index.html"><code>Trace</code></a> like <a href="../../Isla/Run/index.html"><code>Isla.Run</code></a> runs Isla traces.</p><p>Due to the semantic of a register access being the register at the beginning of the trace, all register writes are not done immediately but delayed and stored in the <code>context</code>.</p><p>Typing is enabled if <a href="../Context/index.html#val-typing_enabled"><code>Context.typing_enabled</code></a> returns true for functions that take a context. For other functions, typing is enabled if the <code>dwarf</code> optional argument is passed</p></header><div class="spec module" id="module-Ctxt"><a href="#module-Ctxt" class="anchor"></a><code><span class="keyword">module</span> Ctxt = <a href="../index.html#module-Context">Context</a></code></div><dl><dt class="spec type" id="type-ctxt"><a href="#type-ctxt" class="anchor"></a><code><span class="keyword">type</span> ctxt</code><code> = <a href="../Context/index.html#type-t">Ctxt.t</a></code></dt></dl><dl><dt class="spec value" id="val-expand"><a href="#val-expand" class="anchor"></a><code><span class="keyword">val</span> expand : <span>ctxt:<a href="index.html#type-ctxt">ctxt</a></span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-exp">Base.exp</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-exp">State.exp</a></code></dt><dd><p>Expand a <a href="../index.html"><code>Trace</code></a> expression to a <a href="../../State/index.html"><code>State</code></a> expression, using the context</p></dd></dl><dl><dt class="spec value" id="val-expand_tval"><a href="#val-expand_tval" class="anchor"></a><code><span class="keyword">val</span> expand_tval : <span>ctxt:<a href="index.html#type-ctxt">ctxt</a></span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-exp">Base.exp</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-tval">State.tval</a></code></dt><dd><p>Expand a Trace expression to a typed State expression, using the context.</p><p>If the context enables typing, the expression will actually be typed, otherwise the type will be <code>None</code></p></dd></dl><dl><dt class="spec value" id="val-event_mut"><a href="#val-event_mut" class="anchor"></a><code><span class="keyword">val</span> event_mut : <span>ctxt:<a href="index.html#type-ctxt">ctxt</a></span> <span>&#45;&gt;</span> <a href="../Base/index.html#type-event">Base.event</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Run the event. The modified state is the one inside <code>ctxt</code>.</p></dd></dl><dl><dt class="spec value" id="val-trace_mut"><a href="#val-trace_mut" class="anchor"></a><code><span class="keyword">val</span> trace_mut : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Run a trace on the provided state by mutation. Enable typing if <code>dwarf</code> is provided</p></dd></dl><dl><dt class="spec value" id="val-trace"><a href="#val-trace" class="anchor"></a><code><span class="keyword">val</span> trace : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a></code></dt><dd><p>Run a trace on the provided state by returning an updated copy.</p></dd></dl><dl><dt class="spec value" id="val-trace_pc_mut"><a href="#val-trace_pc_mut" class="anchor"></a><code><span class="keyword">val</span> trace_pc_mut : <span>?&#8288;dwarf:<a href="../../Dw/index.html#type-t">Dw.t</a></span> <span>&#45;&gt;</span> <span>next:int</span> <span>&#45;&gt;</span> <a href="../../State/index.html#type-t">State.t</a> <span>&#45;&gt;</span> <a href="../Base/index.html#type-t">Base.t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Run a trace by mutating the provided state including it's PC. If the trace modified the PC then nothing is done otherwise <code>next</code> is added to it.</p><p>Thus this function automatically handle moving the PC for fall-through instruction</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Run (read-dwarf.Trace.Run)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Trace</a> &#x00BB; Run</nav><header class="odoc-preamble"><h1>Module <code><span>Trace.Run</span></code></h1><p>This module is for running trace from <a href="../index.html"><code>Trace</code></a> like <a href="../../Isla/Run/index.html"><code>Isla.Run</code></a> runs Isla traces.</p><p>Due to the semantic of a register access being the register at the beginning of the trace, all register writes are not done immediately but delayed and stored in the <code>context</code>.</p><p>Typing is enabled if <a href="../Context/index.html#val-typing_enabled"><code>Context.typing_enabled</code></a> returns true for functions that take a context. For other functions, typing is enabled if the <code>dwarf</code> optional argument is passed</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Ctxt"><a href="#module-Ctxt" class="anchor"></a><code><span><span class="keyword">module</span> Ctxt</span><span> = <a href="../Context/index.html">Context</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-ctxt"><a href="#type-ctxt" class="anchor"></a><code><span><span class="keyword">type</span> ctxt</span><span> = <a href="../Context/index.html#type-t">Ctxt.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expand"><a href="#val-expand" class="anchor"></a><code><span><span class="keyword">val</span> expand : <span><span class="label">ctxt</span>:<a href="#type-ctxt">ctxt</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-exp">Base.exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-exp">State.exp</a></span></code></div><div class="spec-doc"><p>Expand a <a href="../index.html"><code>Trace</code></a> expression to a <a href="../../State/index.html"><code>State</code></a> expression, using the context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expand_simplify"><a href="#val-expand_simplify" class="anchor"></a><code><span><span class="keyword">val</span> expand_simplify : <span><span class="label">ctxt</span>:<a href="#type-ctxt">ctxt</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-exp">Base.exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-exp">State.exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expand_tval"><a href="#val-expand_tval" class="anchor"></a><code><span><span class="keyword">val</span> expand_tval : <span><span class="label">ctxt</span>:<a href="#type-ctxt">ctxt</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-exp">Base.exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../State/index.html#type-tval">State.tval</a></span></code></div><div class="spec-doc"><p>Expand a Trace expression to a typed State expression, using the context.</p><p>If the context enables typing, the expression will actually be typed, otherwise the type will be <code>None</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-event_mut"><a href="#val-event_mut" class="anchor"></a><code><span><span class="keyword">val</span> event_mut : <span><span class="label">ctxt</span>:<a href="#type-ctxt">ctxt</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Base/index.html#type-event">Base.event</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Run the event. The modified state is the one inside <code>ctxt</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trace_mut"><a href="#val-trace_mut" class="anchor"></a><code><span><span class="keyword">val</span> trace_mut : 
+  <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?relocation</span>:<a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Run a trace on the provided state by mutation. Enable typing if <code>dwarf</code> is provided</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trace"><a href="#val-trace" class="anchor"></a><code><span><span class="keyword">val</span> trace : 
+  <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?relocation</span>:<a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../../State/index.html#type-t">State.t</a></span></code></div><div class="spec-doc"><p>Run a trace on the provided state by returning an updated copy.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trace_pc_mut"><a href="#val-trace_pc_mut" class="anchor"></a><code><span><span class="keyword">val</span> trace_pc_mut : 
+  <span><span class="optlabel">?dwarf</span>:<a href="../../Dw/index.html#type-t">Dw.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?relocation</span>:<a href="../../Elf/Relocations/index.html#type-rel">Elf.Relocations.rel</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">next</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../../State/index.html#type-t">State.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Base/index.html#type-t">Base.t</a> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Run a trace by mutating the provided state including it's PC. If the trace modified the PC then nothing is done otherwise <code>next</code> is added to it.</p><p>Thus this function automatically handle moving the PC for fall-through instruction</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Trace/index.html b/doc/html/read-dwarf/Trace/index.html
index 2e849dff..a7567ffe 100644
--- a/doc/html/read-dwarf/Trace/index.html
+++ b/doc/html/read-dwarf/Trace/index.html
@@ -1,3 +1,12 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Trace (read-dwarf.Trace)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Trace</nav><h1>Module <code>Trace</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="index.html#module-Base">Base</a></code></span></summary><aside><p>This module defines a new simplified kind of trace to replace Isla traces in the later stages of the instruction semantics processing.</p><p>The traces are even simpler and more easily typable. The possible events are in the type <a href="index.html#type-event"><code>event</code></a> and traces (<a href="index.html#type-t"><code>t</code></a>) are just list of them.</p><p>Compared to Isla, the concept of reading a register do not exist anymore. Nor the concept of pure symbolic variable or Sail structured values. Instead expression can contain only registers and results of previous memory read as decribe in the type <a href="Var/index.html#type-t"><code>Var.t</code></a>. All writing event directly write an entire expression. There are no intermediary variable definitions.</p><p>This raise a problem that if an isla trace reads a register after having written to it, then this is ambiguous to represent.</p><p>Thus a partially monadic representation has been chosen:</p><ul><li>The effect of writes on registers are delayed to the end, which means that registers variable value in every expression is the value of that register at the beginning of the trace. In particular, if there are two write to the register, only the last one have any effect, the other can be deleted.</li><li>The memory operation behave in normal monadic way, in particular a memory read can read the value written by a previous write in the same instruction, even if this is very unlikely.</li></ul><p>In the end, both assertion and register write to different registers can be reordered at will.</p><p>TODO: To make it more clean, getting register writes and assertions out of the trace would make sense like:</p><pre><code class="ml">type mem_event = Read of ... | Write of ...
-type t = { asserts : exp list; reg_writes : (Reg.t * exp) list; mem: mem_event list }</code></pre><p>For all those reason, concatenating two trace semantically is very different that concatenating list of event, and is not implemented yet.</p><p>The important functions are <a href="index.html#val-of_isla"><code>of_isla</code></a> to convert and Isla traces and <a href="index.html#val-simplify"><code>simplify</code></a> for simplify traces.</p></aside><dl><dt class="spec module" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span class="keyword">module</span> Var = <a href="Base/index.html#module-Var">Base.Var</a></code></dt><dd><p>This module contains variable used in traces</p></dd></dl><dl><dt class="spec module" id="module-ExpPp"><a href="#module-ExpPp" class="anchor"></a><code><span class="keyword">module</span> ExpPp = <a href="../Exp/index.html#module-Pp">Exp.Pp</a></code></dt><dd><p>A trace expression. No let bindings, no memory operations</p></dd></dl><div class="spec module" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span class="keyword">module</span> Typed = <a href="../Exp/index.html#module-Typed">Exp.Typed</a></code></div><div class="spec module" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span class="keyword">module</span> Exp = <a href="Base/index.html#module-Exp">Base.Exp</a></code></div><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <a href="Exp/index.html#type-t">Exp.t</a></code></dt><dt class="spec type" id="type-event"><a href="#type-event" class="anchor"></a><code><span class="keyword">type</span> event</code><code> = </code><table class="variant"><tr id="type-event.WriteReg" class="anchored"><td class="def constructor"><a href="#type-event.WriteReg" class="anchor"></a><code>| </code><code><span class="constructor">WriteReg</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-event.reg" class="anchored"><td class="def field"><a href="#type-event.reg" class="anchor"></a><code>reg : <a href="../State/Reg/index.html#type-t">State.Reg.t</a>;</code></td></tr><tr id="type-event.value" class="anchored"><td class="def field"><a href="#type-event.value" class="anchor"></a><code>value : <a href="index.html#type-exp">exp</a>;</code></td></tr></table><code>}</code></td></tr><tr id="type-event.ReadMem" class="anchored"><td class="def constructor"><a href="#type-event.ReadMem" class="anchor"></a><code>| </code><code><span class="constructor">ReadMem</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-event.addr" class="anchored"><td class="def field"><a href="#type-event.addr" class="anchor"></a><code>addr : <a href="index.html#type-exp">exp</a>;</code></td></tr><tr id="type-event.value" class="anchored"><td class="def field"><a href="#type-event.value" class="anchor"></a><code>value : int;</code></td></tr><tr id="type-event.size" class="anchored"><td class="def field"><a href="#type-event.size" class="anchor"></a><code>size : <a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a>;</code></td></tr></table><code>}</code></td></tr><tr id="type-event.WriteMem" class="anchored"><td class="def constructor"><a href="#type-event.WriteMem" class="anchor"></a><code>| </code><code><span class="constructor">WriteMem</span> <span class="keyword">of</span> </code><code>{</code><table class="record"><tr id="type-event.addr" class="anchored"><td class="def field"><a href="#type-event.addr" class="anchor"></a><code>addr : <a href="index.html#type-exp">exp</a>;</code></td></tr><tr id="type-event.value" class="anchored"><td class="def field"><a href="#type-event.value" class="anchor"></a><code>value : <a href="index.html#type-exp">exp</a>;</code></td></tr><tr id="type-event.size" class="anchored"><td class="def field"><a href="#type-event.size" class="anchor"></a><code>size : <a href="../AstGen__Def/Size/index.html#type-t">Ast.Size.t</a>;</code></td></tr></table><code>}</code></td></tr><tr id="type-event.Assert" class="anchored"><td class="def constructor"><a href="#type-event.Assert" class="anchor"></a><code>| </code><code><span class="constructor">Assert</span> <span class="keyword">of</span> <a href="index.html#type-exp">exp</a></code></td></tr></table></dt><dd><p>The event type. See the <a href="index.html"><span>module description</span></a> for more details</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <span><a href="index.html#type-event">event</a> list</span></code></dt></dl><dl><dt class="spec value" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span class="keyword">val</span> iter_var : <span>(<a href="Exp/index.html#type-var">Exp.var</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> unit</code></dt></dl><section><header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2></header><dl><dt class="spec value" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span class="keyword">val</span> pp_exp : <span><span>(<span class="type-var">'a</span>, <a href="Var/index.html#type-t">Var.t</a>, <a href="../Ast/index.html#type-no">Ast.no</a>, <a href="../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Ast/index.html#type-exp">Ast.exp</a></span> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print an expression</p></dd></dl><dl><dt class="spec value" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span class="keyword">val</span> pp_event : <a href="index.html#type-event">event</a> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print an event</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Pretty print a trace</p></dd></dl></section><section><header><h2 id="isla-to-trace-conversion"><a href="#isla-to-trace-conversion" class="anchor"></a>Isla to Trace conversion</h2><p>This section perform the conversion from Isla trace to the traces of this module.</p><p>The conversion is generrally obvious, however there is subtlety: If the Isla trace reads a register after having written it, then the read produce the written expression instead of just the symbolic value of that register. That why there is a <code>written_registers</code> parameter to some function of this section.</p></header><dl><dt class="spec exception" id="exception-OfIslaError"><a href="#exception-OfIslaError" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">OfIslaError</span></code></dt><dd><p>Throw an error in case of local conversion error. Normally a type-checked Isla trace should not fail in this section</p></dd></dl><dl><dt class="spec type" id="type-value_context"><a href="#type-value_context" class="anchor"></a><code><span class="keyword">type</span> value_context</code><code> = <span><a href="index.html#type-exp">exp</a> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></code></dt><dd><p>The context mapping Isla variable numbers to trace expression</p></dd></dl><dl><dt class="spec value" id="val-get_var"><a href="#val-get_var" class="anchor"></a><code><span class="keyword">val</span> get_var : <span><span class="type-var">'a</span> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the exression of the variable at the index. Throw <a href="index.html#exception-OfIslaError"><code>OfIslaError</code></a> if the variable is not bound</p></dd></dl><dl><dt class="spec value" id="val-exp_conv_subst"><a href="#val-exp_conv_subst" class="anchor"></a><code><span class="keyword">val</span> exp_conv_subst : <a href="index.html#type-value_context">value_context</a> <span>&#45;&gt;</span> <a href="../Isla/index.html#type-rexp">Isla.rexp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Convert an Isla expression to a <code>Trace</code> expression by replacing all Isla variable by their value in the context. Throw <a href="index.html#exception-OfIslaError"><code>OfIslaError</code></a> if the substitution fails</p></dd></dl><dl><dt class="spec value" id="val-exp_of_valu"><a href="#val-exp_of_valu" class="anchor"></a><code><span class="keyword">val</span> exp_of_valu : Isla_lang.AST.lrng <span>&#45;&gt;</span> <span><a href="index.html#type-exp">exp</a> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../Isla/index.html">Isla</a>.valu <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Convert an <span class="xref-unresolved" title="unresolved reference to &quot;Isla.valu&quot;"><a href="../Isla/index.html"><code>Isla</code></a>.valu</span> in a expression</p></dd></dl><dl><dt class="spec value" id="val-write_to_valu"><a href="#val-write_to_valu" class="anchor"></a><code><span class="keyword">val</span> write_to_valu : <span><span class="type-var">'a</span> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span>&#45;&gt;</span> <a href="../Isla/index.html">Isla</a>.valu <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write an expression to an <span class="xref-unresolved" title="unresolved reference to &quot;Isla.valu&quot;"><a href="../Isla/index.html"><code>Isla</code></a>.valu</span></p></dd></dl><dl><dt class="spec value" id="val-event_of_isla"><a href="#val-event_of_isla" class="anchor"></a><code><span class="keyword">val</span> event_of_isla : <span>written_registers:<span><span>(<a href="../State/Reg/index.html#type-t">State.Reg.t</a>, <a href="index.html#type-exp">exp</a>)</span> Stdlib.Hashtbl.t</span></span> <span>&#45;&gt;</span> <span>read_counter:<a href="../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span> <span>&#45;&gt;</span> <span>vc:<a href="index.html#type-value_context">value_context</a></span> <span>&#45;&gt;</span> <a href="../Isla/index.html#type-revent">Isla.revent</a> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> option</span></code></dt><dd><p>Convert an isla event to optionally a Trace event, most events are deleted</p></dd></dl><dl><dt class="spec value" id="val-of_isla"><a href="#val-of_isla" class="anchor"></a><code><span class="keyword">val</span> of_isla : <a href="../Isla/index.html#type-rtrc">Isla.rtrc</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Top level function to convert an isla trace to one of this module</p></dd></dl></section><section><header><h2 id="trace-simplification"><a href="#trace-simplification" class="anchor"></a>Trace simplification</h2></header><dl><dt class="spec module" id="module-SimpContext"><a href="#module-SimpContext" class="anchor"></a><code><span class="keyword">module</span> SimpContext = <a href="Base/index.html#module-SimpContext">Base.SimpContext</a></code></dt><dd><p>A instance of <a href="../Z3/ContextCounter/index.html"><code>Z3.ContextCounter</code></a>.</p></dd></dl><div class="spec module" id="module-Z3Tr"><a href="#module-Z3Tr" class="anchor"></a><code><span class="keyword">module</span> Z3Tr = <a href="Base/index.html#module-Z3Tr">Base.Z3Tr</a></code></div><div class="spec module" id="module-VarTbl"><a href="#module-VarTbl" class="anchor"></a><code><span class="keyword">module</span> VarTbl = <a href="Base/index.html#module-VarTbl">Base.VarTbl</a></code></div><dl><dt class="spec value" id="val-declare_non_det"><a href="#val-declare_non_det" class="anchor"></a><code><span class="keyword">val</span> declare_non_det : <a href="../Z3/index.html#type-server">Z3.server</a> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <span><a href="index.html#type-event">event</a> list</span> <span>&#45;&gt;</span> <span><a href="index.html#type-event">event</a> list</span></code></dt><dd><p>Simplify a trace by using Z3. Perform both local expression simplification and global assertion removal (when an assertion is always true)</p></dd></dl></section></details></div></div></div><dl><dt class="spec module" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span class="keyword">module</span> <a href="Base/index.html">Base</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module defines a new simplified kind of trace to replace Isla traces in the later stages of the instruction semantics processing.</p></dd></dl><dl><dt class="spec module" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span class="keyword">module</span> <a href="Cache/index.html">Cache</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provides a caching system for fully processed traces</p></dd></dl><dl><dt class="spec module" id="module-Context"><a href="#module-Context" class="anchor"></a><code><span class="keyword">module</span> <a href="Context/index.html">Context</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide the type for a context to run a trace</p></dd></dl><div class="spec module" id="module-Ctype"><a href="#module-Ctype" class="anchor"></a><code><span class="keyword">module</span> Ctype = <a href="../Ctype/index.html">Ctype</a></code></div><dl><dt class="spec module" id="module-Instr"><a href="#module-Instr" class="anchor"></a><code><span class="keyword">module</span> <a href="Instr/index.html">Instr</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide the representation of an instruction. It only contains generic information about the opcode and not specific information about a place in the code.</p></dd></dl><dl><dt class="spec module" id="module-Run"><a href="#module-Run" class="anchor"></a><code><span class="keyword">module</span> <a href="Run/index.html">Run</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module is for running trace from <a href="index.html"><code>Trace</code></a> like <a href="../Isla/Run/index.html"><code>Isla.Run</code></a> runs Isla traces.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Trace (read-dwarf.Trace)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Trace</nav><header class="odoc-preamble"><h1>Module <code><span>Trace</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="Base/index.html">Base</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec module anchored" id="module-Var"><a href="#module-Var" class="anchor"></a><code><span><span class="keyword">module</span> Var</span><span> = <a href="Base/Var/index.html">Base.Var</a></span></code></div><div class="spec-doc"><p>This module contains variable used in traces</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ExpPp"><a href="#module-ExpPp" class="anchor"></a><code><span><span class="keyword">module</span> ExpPp</span><span> = <a href="../Exp/PpExp/index.html">Exp.Pp</a></span></code></div><div class="spec-doc"><p>A trace expression. No let bindings, no memory operations</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Typed"><a href="#module-Typed" class="anchor"></a><code><span><span class="keyword">module</span> Typed</span><span> = <a href="../Exp/Typed/index.html">Exp.Typed</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Exp"><a href="#module-Exp" class="anchor"></a><code><span><span class="keyword">module</span> Exp</span><span> = <a href="Base/Exp/index.html">Base.Exp</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <a href="Base/Exp/index.html#type-t">Exp.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-event"><a href="#type-event" class="anchor"></a><code><span><span class="keyword">type</span> event</span><span> = <a href="Base/index.html#type-event">Base.event</a></span><span> = </span></code><ol><li id="type-event.WriteReg" class="def variant constructor anchored"><a href="#type-event.WriteReg" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteReg</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-event.reg" class="def record field anchored"><a href="#type-event.reg" class="anchor"></a><code><span>reg : <a href="../State/Reg/index.html#type-t">State.Reg.t</a>;</span></code></li><li id="type-event.value" class="def record field anchored"><a href="#type-event.value" class="anchor"></a><code><span>value : <a href="#type-exp">exp</a>;</span></code></li></ol><code><span>}</span></code></li><li id="type-event.ReadMem" class="def variant constructor anchored"><a href="#type-event.ReadMem" class="anchor"></a><code><span>| </span><span><span class="constructor">ReadMem</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-event.addr" class="def record field anchored"><a href="#type-event.addr" class="anchor"></a><code><span>addr : <a href="#type-exp">exp</a>;</span></code></li><li id="type-event.value" class="def record field anchored"><a href="#type-event.value" class="anchor"></a><code><span>value : int;</span></code></li><li id="type-event.size" class="def record field anchored"><a href="#type-event.size" class="anchor"></a><code><span>size : <a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a>;</span></code></li></ol><code><span>}</span></code></li><li id="type-event.WriteMem" class="def variant constructor anchored"><a href="#type-event.WriteMem" class="anchor"></a><code><span>| </span><span><span class="constructor">WriteMem</span> <span class="keyword">of</span> </span><span>{</span></code><ol><li id="type-event.addr" class="def record field anchored"><a href="#type-event.addr" class="anchor"></a><code><span>addr : <a href="#type-exp">exp</a>;</span></code></li><li id="type-event.value" class="def record field anchored"><a href="#type-event.value" class="anchor"></a><code><span>value : <a href="#type-exp">exp</a>;</span></code></li><li id="type-event.size" class="def record field anchored"><a href="#type-event.size" class="anchor"></a><code><span>size : <a href="../Ast/Base/Size/index.html#type-t">Ast.Size.t</a>;</span></code></li></ol><code><span>}</span></code></li><li id="type-event.Assert" class="def variant constructor anchored"><a href="#type-event.Assert" class="anchor"></a><code><span>| </span><span><span class="constructor">Assert</span> <span class="keyword">of</span> <a href="#type-exp">exp</a></span></code></li></ol></div><div class="spec-doc"><p>The event type. See the <a href="#" title="Trace">module description</a> for more details</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span><a href="#type-event">event</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_var"><a href="#val-iter_var" class="anchor"></a><code><span><span class="keyword">val</span> iter_var : <span><span>(<span><a href="Base/Exp/index.html#type-var">Exp.var</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp_exp"><a href="#val-pp_exp" class="anchor"></a><code><span><span class="keyword">val</span> pp_exp : <span><span><span>(<span class="type-var">'a</span>, <a href="Base/Var/index.html#type-t">Var.t</a>, <a href="../Ast/index.html#type-no">Ast.no</a>, <a href="../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../Ast/index.html#type-exp">Ast.exp</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print an expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_event"><a href="#val-pp_event" class="anchor"></a><code><span><span class="keyword">val</span> pp_event : <span><a href="#type-event">event</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print an event</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a trace</p></div></div><h2 id="isla-to-trace-conversion"><a href="#isla-to-trace-conversion" class="anchor"></a>Isla to Trace conversion</h2><p>This section perform the conversion from Isla trace to the traces of this module.</p><p>The conversion is generrally obvious, however there is subtlety: If the Isla trace reads a register after having written it, then the read produce the written expression instead of just the symbolic value of that register. That why there is a <code>written_registers</code> parameter to some function of this section.</p><div class="odoc-spec"><div class="spec exception anchored" id="exception-OfIslaError"><a href="#exception-OfIslaError" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">OfIslaError</span></span></code></div><div class="spec-doc"><p>Throw an error in case of local conversion error. Normally a type-checked Isla trace should not fail in this section</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value_context"><a href="#type-value_context" class="anchor"></a><code><span><span class="keyword">type</span> value_context</span><span> = <span><a href="#type-exp">exp</a> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span></span></code></div><div class="spec-doc"><p>The context mapping Isla variable numbers to trace expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_var"><a href="#val-get_var" class="anchor"></a><code><span><span class="keyword">val</span> get_var : <span><span><span class="type-var">'a</span> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the exression of the variable at the index. Throw <a href="#exception-OfIslaError"><code>OfIslaError</code></a> if the variable is not bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_conv_subst"><a href="#val-exp_conv_subst" class="anchor"></a><code><span><span class="keyword">val</span> exp_conv_subst : <span><a href="#type-value_context">value_context</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Isla/index.html#type-rexp">Isla.rexp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Convert an Isla expression to a <code>Trace</code> expression by replacing all Isla variable by their value in the context. Throw <a href="#exception-OfIslaError"><code>OfIslaError</code></a> if the substitution fails</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_of_valu"><a href="#val-exp_of_valu" class="anchor"></a><code><span><span class="keyword">val</span> exp_of_valu : 
+  <span><span class="xref-unresolved">Isla_lang</span>.AST.lrng <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-exp">exp</a> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Isla/index.html#type-valu">Isla.valu</a> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Convert an <a href="../Isla/index.html#type-valu"><code>Isla.valu</code></a> in a expression</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_to_valu"><a href="#val-write_to_valu" class="anchor"></a><code><span><span class="keyword">val</span> write_to_valu : <span><span><span class="type-var">'a</span> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Isla/index.html#type-valu">Isla.valu</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Write an expression to an <a href="../Isla/index.html#type-valu"><code>Isla.valu</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-events_of_isla"><a href="#val-events_of_isla" class="anchor"></a><code><span><span class="keyword">val</span> events_of_isla : 
+  <span><span class="label">segments_map</span>:<span><span>(string * int)</span> <a href="../Utils/HashVector/index.html#type-t">Utils.HashVector.t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">written_registers</span>:<span><span>(<a href="../State/Reg/index.html#type-t">State.Reg.t</a>, <a href="#type-exp">exp</a>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">read_counter</span>:<a href="../Utils/Counter/index.html#type-t">Utils.Counter.t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">vc</span>:<a href="#type-value_context">value_context</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="../Isla/index.html#type-revent">Isla.revent</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-event">event</a> list</span></span></code></div><div class="spec-doc"><p>Convert an isla event to Trace events, most events are deleted</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_isla"><a href="#val-of_isla" class="anchor"></a><code><span><span class="keyword">val</span> of_isla : <span><span><a href="../Isla/index.html#type-segment">Isla.segment</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Isla/index.html#type-rtrc">Isla.rtrc</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Top level function to convert an isla trace to one of this module</p></div></div><h2 id="trace-simplification"><a href="#trace-simplification" class="anchor"></a>Trace simplification</h2><div class="odoc-spec"><div class="spec module anchored" id="module-SimpContext"><a href="#module-SimpContext" class="anchor"></a><code><span><span class="keyword">module</span> SimpContext</span><span> = <a href="Base/SimpContext/index.html">Base.SimpContext</a></span></code></div><div class="spec-doc"><p>A instance of <a href="../Z3/ContextCounter/index.html"><code>Z3.ContextCounter</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Z3Tr"><a href="#module-Z3Tr" class="anchor"></a><code><span><span class="keyword">module</span> Z3Tr</span><span> = <a href="Base/Z3Tr/index.html">Base.Z3Tr</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-VarTbl"><a href="#module-VarTbl" class="anchor"></a><code><span><span class="keyword">module</span> VarTbl</span><span> = <a href="Base/VarTbl/index.html">Base.VarTbl</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_non_det"><a href="#val-declare_non_det" class="anchor"></a><code><span><span class="keyword">val</span> declare_non_det : <span><a href="../Z3/index.html#type-server">Z3.server</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><span><a href="#type-event">event</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-event">event</a> list</span></span></code></div><div class="spec-doc"><p>Simplify a trace by using Z3. Perform both local expression simplification and global assertion removal (when an assertion is always true)</p></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Base"><a href="#module-Base" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Base/index.html">Base</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module defines a new simplified kind of trace to replace Isla traces in the later stages of the instruction semantics processing.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cache/index.html">Cache</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides a caching system for fully processed traces</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Context"><a href="#module-Context" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Context/index.html">Context</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide the type for a context to run a trace</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Ctype"><a href="#module-Ctype" class="anchor"></a><code><span><span class="keyword">module</span> Ctype</span><span> = <a href="../Ctype/index.html">Ctype</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Instr"><a href="#module-Instr" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Instr/index.html">Instr</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide the representation of an instruction. It only contains generic information about the opcode and not specific information about a place in the code.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Run"><a href="#module-Run" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Run/index.html">Run</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is for running trace from <a href="#"><code>Trace</code></a> like <a href="../Isla/Run/index.html"><code>Isla.Run</code></a> runs Isla traces.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/TypeInference.html b/doc/html/read-dwarf/TypeInference.html
index da6562d8..9f797dc8 100644
--- a/doc/html/read-dwarf/TypeInference.html
+++ b/doc/html/read-dwarf/TypeInference.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TypeInference (read-dwarf.TypeInference)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; TypeInference</nav><h1 id="type-inference"><a href="#type-inference" class="anchor"></a>Type Inference</h1><p>The type inference engine is a somewhat basic system right now. The types themselves are defined in <a href="Ctype/index.html"><code>Ctype</code></a>, but the type inference engine is in <span class="xref-unresolved" title="unresolved reference to &quot;Trace.Typer&quot;"><a href="Trace/index.html"><code>Trace</code></a>.Typer</span>. This because the type inference is done instruction by instruction over trace expressions, and not directly on state expression.</p></header></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TypeInference (read-dwarf.TypeInference)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; TypeInference</nav><header class="odoc-preamble"><h1 id="type-inference"><a href="#type-inference" class="anchor"></a>Type Inference</h1><p>The type inference engine is a somewhat basic system right now. The types themselves are defined in <a href="Ctype/index.html"><code>Ctype</code></a>, but the type inference engine is in <code>Trace.Typer</code>. This because the type inference is done instruction by instruction over trace expressions, and not directly on state expression.</p></header><div class="odoc-content"></div></body></html>
diff --git a/doc/html/read-dwarf/Utilities.html b/doc/html/read-dwarf/Utilities.html
index f5a90eb8..32f7a16c 100644
--- a/doc/html/read-dwarf/Utilities.html
+++ b/doc/html/read-dwarf/Utilities.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Utilities (read-dwarf.Utilities)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="index.html">Up</a> – <a href="index.html">read-dwarf</a> &#x00BB; Utilities</nav><h1 id="utilities"><a href="#utilities" class="anchor"></a>Utilities</h1><nav class="toc"><ul><li><a href="#standard-library-extensions">Standard library extensions</a></li><li><a href="#bits-and-bytes-manipulation">Bits and Bytes manipulation</a></li><li><a href="#resizable-array-and-other-integer-indexed-data-structures">Resizable array and other integer-indexed data structures</a></li><li><a href="#weak-data-structures">Weak data structures</a></li><li><a href="#exception-management">Exception management</a></li><li><a href="#file-and-socket-management">File and socket management</a></li></ul></nav></header><h2 id="standard-library-extensions"><a href="#standard-library-extensions" class="anchor"></a>Standard library extensions</h2><ul><li><code>Option</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Option.html"><code>Stdlib.Option</code></a>.</li><li><code>Array</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html"><code>Stdlib.Array</code></a></li><li><code>List</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html"><code>Stdlib.List</code></a></li><li><code>Fun</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html"><code>Stdlib.Fun</code></a></li><li><code>Pair</code>: A module to lift operation over pairs</li><li><code>Seq</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Seq.html"><code>Stdlib.Seq</code></a></li><li><code>String</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/String.html"><code>Stdlib.String</code></a></li></ul><h2 id="bits-and-bytes-manipulation"><a href="#bits-and-bytes-manipulation" class="anchor"></a>Bits and Bytes manipulation</h2><ul><li><code>Bits</code>: Intends to provide the same interface as <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Bytes.html"><code>Stdlib.Bytes</code></a> but at the individual bit level. The external type is explicitely <code>bytes</code>.</li><li><code>IntBits</code>: Same interface as <code>Bits</code> but on an integer. This provides understandable ways of moving set of bits around directly in integers without having to think about shifts.</li><li><code>BitVec</code>: Concrete bitvector library based on <code>zarith</code>.</li><li><code>BytesSeq</code>: Implement a view over a <code>bytes</code>. This view can be restricted in a pure interface without requiring to copy the <code>bytes</code>.</li><li><code>RngMap</code>: Map structure that allow to index value by range of addresses. You can bind a whole interval of addresses to a value.</li></ul><h2 id="resizable-array-and-other-integer-indexed-data-structures"><a href="#resizable-array-and-other-integer-indexed-data-structures" class="anchor"></a>Resizable array and other integer-indexed data structures</h2><ul><li><code>Vec</code>: Main resizable array module. Layer on top of the <code>res</code> library.</li><li><code>FullVec</code>: Conceptually a array/vector that binds all the integers to values. It's implemented by a vector and a generator.</li><li><code>HashVector</code>: A Data structure to use a vector as small int to something hashtable. Implemented as a <code>'a option Vec.t</code></li><li><code>IdMap</code>: A hashmap that numbers the bindings such that each binding can be identified by either the key of the integer identifier. Useful for doing symbol numbering for example.</li><li><code>Counter</code>: Just an integer counter to index something. It has a <span class="xref-unresolved" title="unresolved reference to &quot;Counter.get&quot;"><code>Counter</code>.get</span> function that give the next integer each time it's called.</li></ul><h2 id="weak-data-structures"><a href="#weak-data-structures" class="anchor"></a>Weak data structures</h2><p>This module is about addition to the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Weak.html"><code>Stdlib.Weak</code></a> module of the standard library. Those are data structures that do not retain GC ownership of their values, which mean the GC can delete them at any moment.</p><ul><li><code>WeakPtr</code>: A single weak pointer whose pointee can be garbage collected if nothing else points to it.</li><li><code>WeakMap</code>: A Hash map which own the keys but not the values. When a value is cleared by the GC, the binding dissapears entirely from the map.</li></ul><h2 id="exception-management"><a href="#exception-management" class="anchor"></a>Exception management</h2><ul><li><code>Protect</code>: An improvement over <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html#VALprotect"><code>protect</code></a>.</li><li><code>Raise</code>: Convenience function to raise and manage exception in an easier way.</li></ul><h2 id="file-and-socket-management"><a href="#file-and-socket-management" class="anchor"></a>File and socket management</h2><ul><li><code>Files</code>: Various IO facilities around IO channel and file management</li><li><code>Cmd</code>: Library for easily calling external programs and also for keeping them running as background servers.</li><li><code>Cache</code>: Generic library to implement a caching system in the form of a persistent hash table structure on disk.</li></ul></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Utilities (read-dwarf.Utilities)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; <a href="index.html">read-dwarf</a> &#x00BB; Utilities</nav><header class="odoc-preamble"><h1 id="utilities"><a href="#utilities" class="anchor"></a>Utilities</h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#standard-library-extensions">Standard library extensions</a></li><li><a href="#bits-and-bytes-manipulation">Bits and Bytes manipulation</a></li><li><a href="#resizable-array-and-other-integer-indexed-data-structures">Resizable array and other integer-indexed data structures</a></li><li><a href="#weak-data-structures">Weak data structures</a></li><li><a href="#exception-management">Exception management</a></li><li><a href="#file-and-socket-management">File and socket management</a></li></ul></nav></div><div class="odoc-content"><h2 id="standard-library-extensions"><a href="#standard-library-extensions" class="anchor"></a>Standard library extensions</h2><ul><li><code>Option</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Option.html"><code>Stdlib.Option</code></a>.</li><li><code>Array</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html"><code>Stdlib.Array</code></a></li><li><code>List</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html"><code>Stdlib.List</code></a></li><li><code>Fun</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html"><code>Stdlib.Fun</code></a></li><li><code>Pair</code>: A module to lift operation over pairs</li><li><code>Seq</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Seq.html"><code>Stdlib.Seq</code></a></li><li><code>String</code>: extension of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/String.html"><code>Stdlib.String</code></a></li></ul><h2 id="bits-and-bytes-manipulation"><a href="#bits-and-bytes-manipulation" class="anchor"></a>Bits and Bytes manipulation</h2><ul><li><code>Bits</code>: Intends to provide the same interface as <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Bytes.html"><code>Stdlib.Bytes</code></a> but at the individual bit level. The external type is explicitely <code>bytes</code>.</li><li><code>IntBits</code>: Same interface as <code>Bits</code> but on an integer. This provides understandable ways of moving set of bits around directly in integers without having to think about shifts.</li><li><code>BitVec</code>: Concrete bitvector library based on <code>zarith</code>.</li><li><code>BytesSeq</code>: Implement a view over a <code>bytes</code>. This view can be restricted in a pure interface without requiring to copy the <code>bytes</code>.</li><li><code>RngMap</code>: Map structure that allow to index value by range of addresses. You can bind a whole interval of addresses to a value.</li></ul><h2 id="resizable-array-and-other-integer-indexed-data-structures"><a href="#resizable-array-and-other-integer-indexed-data-structures" class="anchor"></a>Resizable array and other integer-indexed data structures</h2><ul><li><code>Vec</code>: Main resizable array module. Layer on top of the <code>res</code> library.</li><li><code>FullVec</code>: Conceptually a array/vector that binds all the integers to values. It's implemented by a vector and a generator.</li><li><code>HashVector</code>: A Data structure to use a vector as small int to something hashtable. Implemented as a <code>'a option Vec.t</code></li><li><code>IdMap</code>: A hashmap that numbers the bindings such that each binding can be identified by either the key of the integer identifier. Useful for doing symbol numbering for example.</li><li><code>Counter</code>: Just an integer counter to index something. It has a <code>Counter.get</code> function that give the next integer each time it's called.</li></ul><h2 id="weak-data-structures"><a href="#weak-data-structures" class="anchor"></a>Weak data structures</h2><p>This module is about addition to the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Weak.html"><code>Stdlib.Weak</code></a> module of the standard library. Those are data structures that do not retain GC ownership of their values, which mean the GC can delete them at any moment.</p><ul><li><code>WeakPtr</code>: A single weak pointer whose pointee can be garbage collected if nothing else points to it.</li><li><code>WeakMap</code>: A Hash map which own the keys but not the values. When a value is cleared by the GC, the binding dissapears entirely from the map.</li></ul><h2 id="exception-management"><a href="#exception-management" class="anchor"></a>Exception management</h2><ul><li><code>Protect</code>: An improvement over <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html#VALprotect"><code>protect</code></a>.</li><li><code>Raise</code>: Convenience function to raise and manage exception in an easier way.</li></ul><h2 id="file-and-socket-management"><a href="#file-and-socket-management" class="anchor"></a>File and socket management</h2><ul><li><code>Files</code>: Various IO facilities around IO channel and file management</li><li><code>Cmd</code>: Library for easily calling external programs and also for keeping them running as background servers.</li><li><code>Cache</code>: Generic library to implement a caching system in the form of a persistent hash table structure on disk.</li></ul></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Array/index.html b/doc/html/read-dwarf/Utils/Array/index.html
index 333b75db..7071f575 100644
--- a/doc/html/read-dwarf/Utils/Array/index.html
+++ b/doc/html/read-dwarf/Utils/Array/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Array (read-dwarf.Utils.Array)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Array</nav><h1>Module <code>Utils.Array</code></h1><nav class="toc"><ul><li><a href="#array-scanning">Array scanning</a></li></ul></nav></header><aside><p>This module is for extending the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html"><code>Array</code></a> module of the standard library</p></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.Array</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> array</span></code></dt></dl><dl><dt class="spec external" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec external" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec external" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec external" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec external" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec external" id="val-create_float"><a href="#val-create_float" class="anchor"></a><code><span class="keyword">val</span> create_float : int <span>&#45;&gt;</span> <span>float array</span></code></dt></dl><dl><dt class="spec value" id="val-make_float"><a href="#val-make_float" class="anchor"></a><code><span class="keyword">val</span> make_float : int <span>&#45;&gt;</span> <span>float array</span></code></dt><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : int <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-make_matrix"><a href="#val-make_matrix" class="anchor"></a><code><span class="keyword">val</span> make_matrix : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> array</span></code></dt><dt class="spec value" id="val-create_matrix"><a href="#val-create_matrix" class="anchor"></a><code><span class="keyword">val</span> create_matrix : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> array</span> array</span></code></dt><dt class="spec value" id="val-append"><a href="#val-append" class="anchor"></a><code><span class="keyword">val</span> append : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span class="keyword">val</span> concat : <span><span><span class="type-var">'a</span> array</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-fill"><a href="#val-fill" class="anchor"></a><code><span class="keyword">val</span> fill : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span class="keyword">val</span> blit : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span class="keyword">val</span> to_list : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-of_list"><a href="#val-of_list" class="anchor"></a><code><span class="keyword">val</span> of_list : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span></code></dt><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span></code></dt><dt class="spec value" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span class="keyword">val</span> fold_left : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span class="keyword">val</span> fold_right : <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span class="keyword">val</span> iter2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span class="keyword">val</span> map2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> array</span></code></dt><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-memq"><a href="#val-memq" class="anchor"></a><code><span class="keyword">val</span> memq : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-sort"><a href="#val-sort" class="anchor"></a><code><span class="keyword">val</span> sort : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-stable_sort"><a href="#val-stable_sort" class="anchor"></a><code><span class="keyword">val</span> stable_sort : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-fast_sort"><a href="#val-fast_sort" class="anchor"></a><code><span class="keyword">val</span> fast_sort : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span class="keyword">val</span> to_seqi : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span class="type-var">'a</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt></dl><dl><dt class="spec external" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span class="keyword">val</span> unsafe_get : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec external" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span class="keyword">val</span> unsafe_set : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt></dl><div class="spec module" id="module-Floatarray"><a href="#module-Floatarray" class="anchor"></a><code><span class="keyword">module</span> Floatarray = Stdlib__array.Floatarray</code></div></details></div></div></div><dl><dt class="spec value" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span class="keyword">val</span> map_mut : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Mutate the array by replacing each value <code>x</code> by <code>f x</code></p></dd></dl><dl><dt class="spec value" id="val-of_list_mapi"><a href="#val-of_list_mapi" class="anchor"></a><code><span class="keyword">val</span> of_list_mapi : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span></code></dt><dd><p><code>of_list_mapi f l = of_list (List.mapi f i l) = mapi f (of_list l)</code></p></dd></dl><dl><dt class="spec value" id="val-of_list_map"><a href="#val-of_list_map" class="anchor"></a><code><span class="keyword">val</span> of_list_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> array</span></code></dt><dd><p><code>of_list_map f l = of_list (List.map f l) = map f (of_list l)</code></p></dd></dl><section><header><h2 id="array-scanning"><a href="#array-scanning" class="anchor"></a>Array scanning</h2></header><dl><dt class="spec value" id="val-find_pair"><a href="#val-find_pair" class="anchor"></a><code><span class="keyword">val</span> find_pair : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int * <span class="type-var">'a</span></code></dt><dd><p>Find the first value satisfying the predicate and return it with its index. Throw <code>Not_found</code> if no value satisfies the predicate</p></dd></dl><dl><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Find the first value satisfying the predicate. Throw <code>Not_found</code> if no value satisfies the predicate</p></dd></dl><dl><dt class="spec value" id="val-find_index"><a href="#val-find_index" class="anchor"></a><code><span class="keyword">val</span> find_index : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> int</code></dt><dd><p>Find the first index whose value satisfies the predicate. Throw <code>Not_found</code> if no value satisfies the predicate</p></dd></dl><dl><dt class="spec value" id="val-find_all_pairs"><a href="#val-find_all_pairs" class="anchor"></a><code><span class="keyword">val</span> find_all_pairs : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> list</span></code></dt><dd><p>Find all the values satisfying the predicate and return them with their index.</p></dd></dl><dl><dt class="spec value" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span class="keyword">val</span> find_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dd><p>Find all the values satisfying the predicate</p></dd></dl><dl><dt class="spec value" id="val-find_all_indices"><a href="#val-find_all_indices" class="anchor"></a><code><span class="keyword">val</span> find_all_indices : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>int list</span></code></dt><dd><p>Find all the indices whose value satisfies the predicate</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Array (read-dwarf.Utils.Array)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Array</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Array</span></code></h1><p>This module is for extending the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html"><code>Array</code></a> module of the standard library</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#array-scanning">Array scanning</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.Array <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-create_float"><a href="#val-create_float" class="anchor"></a><code><span><span class="keyword">val</span> create_float : <span>int <span class="arrow">&#45;&gt;</span></span> <span>float array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make_matrix"><a href="#val-make_matrix" class="anchor"></a><code><span><span class="keyword">val</span> make_matrix : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-append"><a href="#val-append" class="anchor"></a><code><span><span class="keyword">val</span> append : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><span><span><span class="type-var">'a</span> array</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fill"><a href="#val-fill" class="anchor"></a><code><span><span class="keyword">val</span> fill : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span><span class="keyword">val</span> blit : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_list"><a href="#val-of_list" class="anchor"></a><code><span><span class="keyword">val</span> of_list : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_inplace"><a href="#val-map_inplace" class="anchor"></a><code><span><span class="keyword">val</span> map_inplace : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi_inplace"><a href="#val-mapi_inplace" class="anchor"></a><code><span><span class="keyword">val</span> mapi_inplace : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left_map"><a href="#val-fold_left_map" class="anchor"></a><code><span><span class="keyword">val</span> fold_left_map : 
+  <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'acc</span> * <span><span class="type-var">'b</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span><span class="keyword">val</span> fold_right : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span><span class="keyword">val</span> iter2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all2"><a href="#val-for_all2" class="anchor"></a><code><span><span class="keyword">val</span> for_all2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists2"><a href="#val-exists2" class="anchor"></a><code><span><span class="keyword">val</span> exists2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-memq"><a href="#val-memq" class="anchor"></a><code><span><span class="keyword">val</span> memq : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_map"><a href="#val-find_map" class="anchor"></a><code><span><span class="keyword">val</span> find_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_mapi"><a href="#val-find_mapi" class="anchor"></a><code><span><span class="keyword">val</span> find_mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span> * <span><span class="type-var">'b</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-combine"><a href="#val-combine" class="anchor"></a><code><span><span class="keyword">val</span> combine : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort"><a href="#val-sort" class="anchor"></a><code><span><span class="keyword">val</span> sort : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stable_sort"><a href="#val-stable_sort" class="anchor"></a><code><span><span class="keyword">val</span> stable_sort : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fast_sort"><a href="#val-fast_sort" class="anchor"></a><code><span><span class="keyword">val</span> fast_sort : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span><span class="keyword">val</span> to_seqi : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_get : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_set : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Floatarray"><a href="#module-Floatarray" class="anchor"></a><code><span><span class="keyword">module</span> Floatarray</span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span><span class="keyword">val</span> map_mut : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Mutate the array by replacing each value <code>x</code> by <code>f x</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_list_mapi"><a href="#val-of_list_mapi" class="anchor"></a><code><span><span class="keyword">val</span> of_list_mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> array</span></span></code></div><div class="spec-doc"><p><code>of_list_mapi f l = of_list (List.mapi f i l) = mapi f (of_list l)</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_list_map"><a href="#val-of_list_map" class="anchor"></a><code><span><span class="keyword">val</span> of_list_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> array</span></span></code></div><div class="spec-doc"><p><code>of_list_map f l = of_list (List.map f l) = map f (of_list l)</code></p></div></div><h2 id="array-scanning"><a href="#array-scanning" class="anchor"></a>Array scanning</h2><div class="odoc-spec"><div class="spec value anchored" id="val-find_pair"><a href="#val-find_pair" class="anchor"></a><code><span><span class="keyword">val</span> find_pair : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> int * <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Find the first value satisfying the predicate and return it with its index. Throw <code>Not_found</code> if no value satisfies the predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Find the first value satisfying the predicate. Throw <code>Not_found</code> if no value satisfies the predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_index"><a href="#val-find_index" class="anchor"></a><code><span><span class="keyword">val</span> find_index : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Find the first index whose value satisfies the predicate. Throw <code>Not_found</code> if no value satisfies the predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all_pairs"><a href="#val-find_all_pairs" class="anchor"></a><code><span><span class="keyword">val</span> find_all_pairs : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> list</span></span></code></div><div class="spec-doc"><p>Find all the values satisfying the predicate and return them with their index.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Find all the values satisfying the predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all_indices"><a href="#val-find_all_indices" class="anchor"></a><code><span><span class="keyword">val</span> find_all_indices : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int list</span></span></code></div><div class="spec-doc"><p>Find all the indices whose value satisfies the predicate</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/BitVec/index.html b/doc/html/read-dwarf/Utils/BitVec/index.html
index 8a7ca738..f788545d 100644
--- a/doc/html/read-dwarf/Utils/BitVec/index.html
+++ b/doc/html/read-dwarf/Utils/BitVec/index.html
@@ -1,2 +1,8 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BitVec (read-dwarf.Utils.BitVec)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; BitVec</nav><h1>Module <code>Utils.BitVec</code></h1><nav class="toc"><ul><li><a href="#integer-conversions">Integer conversions</a></li><li><a href="#bytes-conversions">Bytes conversions</a></li><li><a href="#string-conversions,-printing">String conversions, printing</a></li><li><a href="#arithmetic">Arithmetic</a></li><li><a href="#bit-manipulation">Bit manipulation</a></li><li><a href="#infix-operators">Infix operators</a></li></ul></nav></header><aside><p>This module provides an interface for a bit vector of dynamic size.</p><p>For now this is entirely based on <code>zarith</code>.</p><p>TODO: It could be nice to export this as a separate library on opam at some point</p><p>The value of type t is semantically pure and can be compare with polymorphic operators. It will compare the size first, then the value.</p><p>The size of bit vectors must always be strictly positive.</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of a bitvector</p></dd></dl><dl><dt class="spec exception" id="exception-SizeMismatch"><a href="#exception-SizeMismatch" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">SizeMismatch</span> <span class="keyword">of</span> int * int</code></dt><dd><p>Raise when the runtime size do not match on operation that require so (like <a href="index.html#val-add"><code>add</code></a>)</p></dd></dl><dl><dt class="spec value" id="val-size"><a href="#val-size" class="anchor"></a><code><span class="keyword">val</span> size : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>The size of the bitvector</p></dd></dl><dl><dt class="spec value" id="val-zero"><a href="#val-zero" class="anchor"></a><code><span class="keyword">val</span> zero : <span>size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>The bitvector representing 0 of specified size</p></dd></dl><dl><dt class="spec value" id="val-one"><a href="#val-one" class="anchor"></a><code><span class="keyword">val</span> one : <span>size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>The bitvector representing 1 of specified size</p></dd></dl><dl><dt class="spec value" id="val-minus_one"><a href="#val-minus_one" class="anchor"></a><code><span class="keyword">val</span> minus_one : <span>size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>The bitvector representing -1 of specified size</p></dd></dl><section><header><h2 id="integer-conversions"><a href="#integer-conversions" class="anchor"></a>Integer conversions</h2></header><dl><dt class="spec value" id="val-to_z"><a href="#val-to_z" class="anchor"></a><code><span class="keyword">val</span> to_z : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> Z.t</code></dt><dd><p>To a signed big integer</p></dd></dl><dl><dt class="spec value" id="val-to_uz"><a href="#val-to_uz" class="anchor"></a><code><span class="keyword">val</span> to_uz : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> Z.t</code></dt><dd><p>To an unsigned big integer</p></dd></dl><dl><dt class="spec value" id="val-of_z"><a href="#val-of_z" class="anchor"></a><code><span class="keyword">val</span> of_z : <span>size:int</span> <span>&#45;&gt;</span> Z.t <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Of bit integer. Wrapped modulo <code>2^size</code>.</p></dd></dl><dl><dt class="spec value" id="val-to_int"><a href="#val-to_int" class="anchor"></a><code><span class="keyword">val</span> to_int : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>To a signed integer. Fail if it doesn't fit</p></dd></dl><dl><dt class="spec value" id="val-to_uint"><a href="#val-to_uint" class="anchor"></a><code><span class="keyword">val</span> to_uint : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>To an unsigned integer. Fail if it doesn't fit without wrapping i.e the result is still positive</p></dd></dl><dl><dt class="spec value" id="val-of_int"><a href="#val-of_int" class="anchor"></a><code><span class="keyword">val</span> of_int : <span>size:int</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Of integer. Wrapped modulo <code>size</code>.</p></dd></dl><dl><dt class="spec value" id="val-to_bool"><a href="#val-to_bool" class="anchor"></a><code><span class="keyword">val</span> to_bool : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Convert a one size bitvector to bool. Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if the bitvector is not one-sized</p></dd></dl><dl><dt class="spec value" id="val-of_bool"><a href="#val-of_bool" class="anchor"></a><code><span class="keyword">val</span> of_bool : bool <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a one-sized bitvector representing the boolean</p></dd></dl></section><section><header><h2 id="bytes-conversions"><a href="#bytes-conversions" class="anchor"></a>Bytes conversions</h2></header><dl><dt class="spec value" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span class="keyword">val</span> to_bytes : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bytes</code></dt><dd><p>Return the shortest bytes that represent the bitvector in little-endian. There may be extra bits (if size is not a multiple of 8) which are zeros.</p><p>This bytes may be shorter that the bitvector size, for example the bitvector 1 of size 64bits, will still be returned by this function as a single byte 1. For another behavior, see <a href="index.html#val-to_bytes_exact"><code>to_bytes_exact</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-to_bytes_exact"><a href="#val-to_bytes_exact" class="anchor"></a><code><span class="keyword">val</span> to_bytes_exact : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bytes</code></dt><dd><p>Return a bytes representation of mininal length to encompass the whole bitvector size. Extra bits (if size is not a multiple of 8) are zeros.</p></dd></dl><dl><dt class="spec value" id="val-bytes_store"><a href="#val-bytes_store" class="anchor"></a><code><span class="keyword">val</span> bytes_store : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Store the bitvector in the bytes at the specified offset in little endian. The bitvector size must be a multiple of 8 or <code>Invalid_argument</code> is thrown</p></dd></dl><dl><dt class="spec value" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span class="keyword">val</span> of_bytes : <span>size:int</span> <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Read a bitvector from a bytes data (little endian)</p></dd></dl><dl><dt class="spec value" id="val-bytes_load"><a href="#val-bytes_load" class="anchor"></a><code><span class="keyword">val</span> bytes_load : <span>size:int</span> <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Load a bitvector of <code>size</code> bits from the bytes at the specified offset (little endian). <code>size</code> must be a multiple of 8 or <code>Invalid_argument</code> is thrown</p></dd></dl></section><section><header><h2 id="string-conversions,-printing"><a href="#string-conversions,-printing" class="anchor"></a>String conversions, printing</h2></header><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : <span>?&#8288;base:int</span> <span>&#45;&gt;</span> <span>size:int</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Parse a string with specified <code>base</code> (10 if unspecified) and return a bitvector of size <code>size</code>. If the string is too big, the integer is still parsed and then wrapped modulo <code>2^size</code></p></dd></dl><dl><dt class="spec value" id="val-of_substring"><a href="#val-of_substring" class="anchor"></a><code><span class="keyword">val</span> of_substring : <span>?&#8288;base:int</span> <span>&#45;&gt;</span> <span>size:int</span> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-of_string"><code>of_string</code></a> but on the substring starting at <code>pos</code> of length <code>len</code>.</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <span>?&#8288;base:int</span> <span>&#45;&gt;</span> <span>?&#8288;unsigned:bool</span> <span>&#45;&gt;</span> <span>?&#8288;force_width:bool</span> <span>&#45;&gt;</span> <span>?&#8288;prefix:bool</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert the value to a string representation in the specified <code>base</code>.</p><p><code>base</code> can only be 2, 8, 10 or 16, otherwise the function fails.</p><p>Set <code>unsigned</code> to true to have unsigned values (signed by default).</p><p>Set <code>prefix</code> to true to have the <code>0x/0o/0b</code> prefix (no prefix by default)</p><p>Set <code>force_width</code> to false to not have a digit length matching the bitvector length, otherwise leading zeros will be inserted to match the length.</p></dd></dl><dl><dt class="spec value" id="val-of_smt"><a href="#val-of_smt" class="anchor"></a><code><span class="keyword">val</span> of_smt : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert a bitvector in the SMTLib format to a <a href="index.html#type-t"><code>t</code></a></p></dd></dl><dl><dt class="spec value" id="val-to_smt"><a href="#val-to_smt" class="anchor"></a><code><span class="keyword">val</span> to_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert a bitvector to the SMTLib format</p></dd></dl><dl><dt class="spec value" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span class="keyword">val</span> pp_smt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Print a bitvector with the SMTLib format</p></dd></dl></section><section><header><h2 id="arithmetic"><a href="#arithmetic" class="anchor"></a>Arithmetic</h2></header><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add the values. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></dd></dl><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Subtract the values. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Negate the value. Wrap if the value is the smaller integer (It will stay the smallest integer)</p></dd></dl><dl><dt class="spec value" id="val-mul"><a href="#val-mul" class="anchor"></a><code><span class="keyword">val</span> mul : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Multiply the values. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></dd></dl><dl><dt class="spec value" id="val-sdiv"><a href="#val-sdiv" class="anchor"></a><code><span class="keyword">val</span> sdiv : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Divide the values as signed integers. Result is of the same size as the inputs.</p><p>It rounds the result toward zero.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ.</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></dd></dl><dl><dt class="spec value" id="val-srem"><a href="#val-srem" class="anchor"></a><code><span class="keyword">val</span> srem : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take the remainder of the signed division. Result is of the same size as the inputs.</p><p><code> a = sdiv a b * b + srem a b </code></p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ.</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></dd></dl><dl><dt class="spec value" id="val-smod"><a href="#val-smod" class="anchor"></a><code><span class="keyword">val</span> smod : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take the signed modulo. The result has the sign of the divisor. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ.</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></dd></dl><dl><dt class="spec value" id="val-udiv"><a href="#val-udiv" class="anchor"></a><code><span class="keyword">val</span> udiv : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Divide the values as unsigned integers. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></dd></dl><dl><dt class="spec value" id="val-urem"><a href="#val-urem" class="anchor"></a><code><span class="keyword">val</span> urem : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the remainder of the unsigned division. Result if of the same size as the inputs.</p><p><code> a = udiv a b * b + urem a b </code></p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></dd></dl></section><section><header><h2 id="bit-manipulation"><a href="#bit-manipulation" class="anchor"></a>Bit manipulation</h2></header><dl><dt class="spec value" id="val-logand"><a href="#val-logand" class="anchor"></a><code><span class="keyword">val</span> logand : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Bitwise and of the values. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></dd></dl><dl><dt class="spec value" id="val-logor"><a href="#val-logor" class="anchor"></a><code><span class="keyword">val</span> logor : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Bitwise or of the values. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></dd></dl><dl><dt class="spec value" id="val-logxor"><a href="#val-logxor" class="anchor"></a><code><span class="keyword">val</span> logxor : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Bitwise xor of the values. Result is of the same size as the inputs.</p><p>Throw <a href="index.html#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></dd></dl><dl><dt class="spec value" id="val-lognot"><a href="#val-lognot" class="anchor"></a><code><span class="keyword">val</span> lognot : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Bitwise not of the value. Result is of the same size as the input.</p></dd></dl><dl><dt class="spec value" id="val-redor"><a href="#val-redor" class="anchor"></a><code><span class="keyword">val</span> redor : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Do an or of all the bits in the bitvector</p></dd></dl><dl><dt class="spec value" id="val-redand"><a href="#val-redand" class="anchor"></a><code><span class="keyword">val</span> redand : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Do an and of all the bits in the bitvector</p></dd></dl><dl><dt class="spec value" id="val-shift_left"><a href="#val-shift_left" class="anchor"></a><code><span class="keyword">val</span> shift_left : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Do a left shift. The second argument must be non-negative</p></dd></dl><dl><dt class="spec value" id="val-shift_left_bv"><a href="#val-shift_left_bv" class="anchor"></a><code><span class="keyword">val</span> shift_left_bv : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-shift_left"><code>shift_left</code></a> but the second argument is also a bitvector of any size interpreted as unsigned</p></dd></dl><dl><dt class="spec value" id="val-shift_right_arith"><a href="#val-shift_right_arith" class="anchor"></a><code><span class="keyword">val</span> shift_right_arith : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Do an arithmetic right shift (copy the sign bit). The second argument must be non-negative</p></dd></dl><dl><dt class="spec value" id="val-shift_right_arith_bv"><a href="#val-shift_right_arith_bv" class="anchor"></a><code><span class="keyword">val</span> shift_right_arith_bv : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-shift_right_arith"><code>shift_right_arith</code></a> but the second argument is also a bitvector of any size interpreted as unsigned</p></dd></dl><dl><dt class="spec value" id="val-shift_right_logic"><a href="#val-shift_right_logic" class="anchor"></a><code><span class="keyword">val</span> shift_right_logic : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Do an logical right shift (insert zeroes). The second argument must be non-negative</p></dd></dl><dl><dt class="spec value" id="val-shift_right_logic_bv"><a href="#val-shift_right_logic_bv" class="anchor"></a><code><span class="keyword">val</span> shift_right_logic_bv : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-shift_right_logic"><code>shift_right_logic</code></a> but the second argument is also a bitvector of any size interpreted as unsigned</p></dd></dl><dl><dt class="spec value" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span class="keyword">val</span> concat : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Concatenates the bitvectors</p></dd></dl><dl><dt class="spec value" id="val-extract"><a href="#val-extract" class="anchor"></a><code><span class="keyword">val</span> extract : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>extract bv a b</code> extract bits <code>a</code> to <code>b</code> included from <code>bv</code>. Indices start at 0</p></dd></dl><dl><dt class="spec value" id="val-zero_extend"><a href="#val-zero_extend" class="anchor"></a><code><span class="keyword">val</span> zero_extend : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add the second argument of zeroes to the left</p></dd></dl><dl><dt class="spec value" id="val-sign_extend"><a href="#val-sign_extend" class="anchor"></a><code><span class="keyword">val</span> sign_extend : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Copy the bit sign as much as specified by the integer on the left</p></dd></dl></section><section><header><h2 id="infix-operators"><a href="#infix-operators" class="anchor"></a>Infix operators</h2><p>Divisions do not have any operators because signed and unsigned division have different semantics</p></header><dl><dt class="spec value" id="val-(+)"><a href="#val-(+)" class="anchor"></a><code><span class="keyword">val</span> (+) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-add"><code>add</code></a></p></dd></dl><dl><dt class="spec value" id="val-(-)"><a href="#val-(-)" class="anchor"></a><code><span class="keyword">val</span> (-) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-sub"><code>sub</code></a></p></dd></dl><dl><dt class="spec value" id="val-(*)"><a href="#val-(*)" class="anchor"></a><code><span class="keyword">val</span> (*) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-mul"><code>mul</code></a></p></dd></dl><dl><dt class="spec value" id="val-(~-)"><a href="#val-(~-)" class="anchor"></a><code><span class="keyword">val</span> (~-) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-neg"><code>neg</code></a></p></dd></dl><dl><dt class="spec value" id="val-(lsl)"><a href="#val-(lsl)" class="anchor"></a><code><span class="keyword">val</span> (lsl) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-shift_left_bv"><code>shift_left_bv</code></a></p></dd></dl><dl><dt class="spec value" id="val-asl"><a href="#val-asl" class="anchor"></a><code><span class="keyword">val</span> asl : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-shift_left_bv"><code>shift_left_bv</code></a></p></dd></dl><dl><dt class="spec value" id="val-(lsr)"><a href="#val-(lsr)" class="anchor"></a><code><span class="keyword">val</span> (lsr) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-shift_right_logic_bv"><code>shift_right_logic_bv</code></a></p></dd></dl><dl><dt class="spec value" id="val-(asr)"><a href="#val-(asr)" class="anchor"></a><code><span class="keyword">val</span> (asr) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-shift_right_arith_bv"><code>shift_right_arith_bv</code></a></p></dd></dl><dl><dt class="spec value" id="val-(lnot)"><a href="#val-(lnot)" class="anchor"></a><code><span class="keyword">val</span> (lnot) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-lognot"><code>lognot</code></a></p></dd></dl><dl><dt class="spec value" id="val-(land)"><a href="#val-(land)" class="anchor"></a><code><span class="keyword">val</span> (land) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-logand"><code>logand</code></a></p></dd></dl><dl><dt class="spec value" id="val-(lor)"><a href="#val-(lor)" class="anchor"></a><code><span class="keyword">val</span> (lor) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-logor"><code>logor</code></a></p></dd></dl><dl><dt class="spec value" id="val-(lxor)"><a href="#val-(lxor)" class="anchor"></a><code><span class="keyword">val</span> (lxor) : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><a href="index.html#val-logxor"><code>logxor</code></a></p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BitVec (read-dwarf.Utils.BitVec)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; BitVec</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.BitVec</span></code></h1><p>This module provides an interface for a bit vector of dynamic size.</p><p>For now this is entirely based on <code>zarith</code>.</p><p>TODO: It could be nice to export this as a separate library on opam at some point</p><p>The value of type t is semantically pure and can be compare with polymorphic operators. It will compare the size first, then the value.</p><p>The size of bit vectors must always be strictly positive.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#integer-conversions">Integer conversions</a></li><li><a href="#bytes-conversions">Bytes conversions</a></li><li><a href="#string-conversions,-printing">String conversions, printing</a></li><li><a href="#arithmetic">Arithmetic</a></li><li><a href="#bit-manipulation">Bit manipulation</a></li><li><a href="#infix-operators">Infix operators</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of a bitvector</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-SizeMismatch"><a href="#exception-SizeMismatch" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">SizeMismatch</span> <span class="keyword">of</span> int * int</span></code></div><div class="spec-doc"><p>Raise when the runtime size do not match on operation that require so (like <a href="#val-add"><code>add</code></a>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-size"><a href="#val-size" class="anchor"></a><code><span><span class="keyword">val</span> size : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>The size of the bitvector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-zero"><a href="#val-zero" class="anchor"></a><code><span><span class="keyword">val</span> zero : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The bitvector representing 0 of specified size</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-one"><a href="#val-one" class="anchor"></a><code><span><span class="keyword">val</span> one : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The bitvector representing 1 of specified size</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-minus_one"><a href="#val-minus_one" class="anchor"></a><code><span><span class="keyword">val</span> minus_one : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>The bitvector representing -1 of specified size</p></div></div><h2 id="integer-conversions"><a href="#integer-conversions" class="anchor"></a>Integer conversions</h2><div class="odoc-spec"><div class="spec value anchored" id="val-to_z"><a href="#val-to_z" class="anchor"></a><code><span><span class="keyword">val</span> to_z : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Z</span>.t</span></code></div><div class="spec-doc"><p>To a signed big integer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_uz"><a href="#val-to_uz" class="anchor"></a><code><span><span class="keyword">val</span> to_uz : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Z</span>.t</span></code></div><div class="spec-doc"><p>To an unsigned big integer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_z"><a href="#val-of_z" class="anchor"></a><code><span><span class="keyword">val</span> of_z : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Z</span>.t <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Of bit integer. Wrapped modulo <code>2^size</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_int"><a href="#val-to_int" class="anchor"></a><code><span><span class="keyword">val</span> to_int : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>To a signed integer. Fail if it doesn't fit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_uint"><a href="#val-to_uint" class="anchor"></a><code><span><span class="keyword">val</span> to_uint : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>To an unsigned integer. Fail if it doesn't fit without wrapping i.e the result is still positive</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_int"><a href="#val-of_int" class="anchor"></a><code><span><span class="keyword">val</span> of_int : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Of integer. Wrapped modulo <code>size</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bool"><a href="#val-to_bool" class="anchor"></a><code><span><span class="keyword">val</span> to_bool : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Convert a one size bitvector to bool. Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if the bitvector is not one-sized</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bool"><a href="#val-of_bool" class="anchor"></a><code><span><span class="keyword">val</span> of_bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a one-sized bitvector representing the boolean</p></div></div><h2 id="bytes-conversions"><a href="#bytes-conversions" class="anchor"></a>Bytes conversions</h2><div class="odoc-spec"><div class="spec value anchored" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span><span class="keyword">val</span> to_bytes : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div><div class="spec-doc"><p>Return the shortest bytes that represent the bitvector in little-endian. There may be extra bits (if size is not a multiple of 8) which are zeros.</p><p>This bytes may be shorter that the bitvector size, for example the bitvector 1 of size 64bits, will still be returned by this function as a single byte 1. For another behavior, see <a href="#val-to_bytes_exact"><code>to_bytes_exact</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bytes_exact"><a href="#val-to_bytes_exact" class="anchor"></a><code><span><span class="keyword">val</span> to_bytes_exact : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div><div class="spec-doc"><p>Return a bytes representation of mininal length to encompass the whole bitvector size. Extra bits (if size is not a multiple of 8) are zeros.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_store"><a href="#val-bytes_store" class="anchor"></a><code><span><span class="keyword">val</span> bytes_store : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Store the bitvector in the bytes at the specified offset in little endian. The bitvector size must be a multiple of 8 or <code>Invalid_argument</code> is thrown</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span><span class="keyword">val</span> of_bytes : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Read a bitvector from a bytes data (little endian)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_load"><a href="#val-bytes_load" class="anchor"></a><code><span><span class="keyword">val</span> bytes_load : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Load a bitvector of <code>size</code> bits from the bytes at the specified offset (little endian). <code>size</code> must be a multiple of 8 or <code>Invalid_argument</code> is thrown</p></div></div><h2 id="string-conversions,-printing"><a href="#string-conversions,-printing" class="anchor"></a>String conversions, printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span><span class="optlabel">?base</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Parse a string with specified <code>base</code> (10 if unspecified) and return a bitvector of size <code>size</code>. If the string is too big, the integer is still parsed and then wrapped modulo <code>2^size</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_substring"><a href="#val-of_substring" class="anchor"></a><code><span><span class="keyword">val</span> of_substring : <span><span class="optlabel">?base</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-of_string"><code>of_string</code></a> but on the substring starting at <code>pos</code> of length <code>len</code>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : 
+  <span><span class="optlabel">?base</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?unsigned</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?force_width</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?prefix</span>:bool <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  string</span></code></div><div class="spec-doc"><p>Convert the value to a string representation in the specified <code>base</code>.</p><p><code>base</code> can only be 2, 8, 10 or 16, otherwise the function fails.</p><p>Set <code>unsigned</code> to true to have unsigned values (signed by default).</p><p>Set <code>prefix</code> to true to have the <code>0x/0o/0b</code> prefix (no prefix by default)</p><p>Set <code>force_width</code> to false to not have a digit length matching the bitvector length, otherwise leading zeros will be inserted to match the length.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_smt"><a href="#val-of_smt" class="anchor"></a><code><span><span class="keyword">val</span> of_smt : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert a bitvector in the SMTLib format to a <a href="#type-t"><code>t</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_smt"><a href="#val-to_smt" class="anchor"></a><code><span><span class="keyword">val</span> to_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert a bitvector to the SMTLib format</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_smt"><a href="#val-pp_smt" class="anchor"></a><code><span><span class="keyword">val</span> pp_smt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Print a bitvector with the SMTLib format</p></div></div><h2 id="arithmetic"><a href="#arithmetic" class="anchor"></a>Arithmetic</h2><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add the values. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Subtract the values. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span><span class="keyword">val</span> neg : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Negate the value. Wrap if the value is the smaller integer (It will stay the smallest integer)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mul"><a href="#val-mul" class="anchor"></a><code><span><span class="keyword">val</span> mul : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Multiply the values. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sdiv"><a href="#val-sdiv" class="anchor"></a><code><span><span class="keyword">val</span> sdiv : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Divide the values as signed integers. Result is of the same size as the inputs.</p><p>It rounds the result toward zero.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ.</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-srem"><a href="#val-srem" class="anchor"></a><code><span><span class="keyword">val</span> srem : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Take the remainder of the signed division. Result is of the same size as the inputs.</p><p><code> a = sdiv a b * b + srem a b </code></p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ.</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-smod"><a href="#val-smod" class="anchor"></a><code><span><span class="keyword">val</span> smod : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Take the signed modulo. The result has the sign of the divisor. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ.</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-udiv"><a href="#val-udiv" class="anchor"></a><code><span><span class="keyword">val</span> udiv : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Divide the values as unsigned integers. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-urem"><a href="#val-urem" class="anchor"></a><code><span><span class="keyword">val</span> urem : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the remainder of the unsigned division. Result if of the same size as the inputs.</p><p><code> a = udiv a b * b + urem a b </code></p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p><p>Throw <code>Division_by_zero</code> if there is a division by zero.</p></div></div><h2 id="bit-manipulation"><a href="#bit-manipulation" class="anchor"></a>Bit manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-logand"><a href="#val-logand" class="anchor"></a><code><span><span class="keyword">val</span> logand : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Bitwise and of the values. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-logor"><a href="#val-logor" class="anchor"></a><code><span><span class="keyword">val</span> logor : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Bitwise or of the values. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-logxor"><a href="#val-logxor" class="anchor"></a><code><span><span class="keyword">val</span> logxor : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Bitwise xor of the values. Result is of the same size as the inputs.</p><p>Throw <a href="#exception-SizeMismatch"><code>SizeMismatch</code></a> if sizes differ</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lognot"><a href="#val-lognot" class="anchor"></a><code><span><span class="keyword">val</span> lognot : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Bitwise not of the value. Result is of the same size as the input.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-redor"><a href="#val-redor" class="anchor"></a><code><span><span class="keyword">val</span> redor : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Do an or of all the bits in the bitvector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-redand"><a href="#val-redand" class="anchor"></a><code><span><span class="keyword">val</span> redand : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Do an and of all the bits in the bitvector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shift_left"><a href="#val-shift_left" class="anchor"></a><code><span><span class="keyword">val</span> shift_left : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Do a left shift. The second argument must be non-negative</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shift_left_bv"><a href="#val-shift_left_bv" class="anchor"></a><code><span><span class="keyword">val</span> shift_left_bv : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-shift_left"><code>shift_left</code></a> but the second argument is also a bitvector of any size interpreted as unsigned</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shift_right_arith"><a href="#val-shift_right_arith" class="anchor"></a><code><span><span class="keyword">val</span> shift_right_arith : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Do an arithmetic right shift (copy the sign bit). The second argument must be non-negative</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shift_right_arith_bv"><a href="#val-shift_right_arith_bv" class="anchor"></a><code><span><span class="keyword">val</span> shift_right_arith_bv : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-shift_right_arith"><code>shift_right_arith</code></a> but the second argument is also a bitvector of any size interpreted as unsigned</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shift_right_logic"><a href="#val-shift_right_logic" class="anchor"></a><code><span><span class="keyword">val</span> shift_right_logic : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Do an logical right shift (insert zeroes). The second argument must be non-negative</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shift_right_logic_bv"><a href="#val-shift_right_logic_bv" class="anchor"></a><code><span><span class="keyword">val</span> shift_right_logic_bv : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-shift_right_logic"><code>shift_right_logic</code></a> but the second argument is also a bitvector of any size interpreted as unsigned</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Concatenates the bitvectors</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-extract"><a href="#val-extract" class="anchor"></a><code><span><span class="keyword">val</span> extract : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>extract bv a b</code> extract bits <code>a</code> to <code>b</code> included from <code>bv</code>. Indices start at 0</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-zero_extend"><a href="#val-zero_extend" class="anchor"></a><code><span><span class="keyword">val</span> zero_extend : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add the second argument of zeroes to the left</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sign_extend"><a href="#val-sign_extend" class="anchor"></a><code><span><span class="keyword">val</span> sign_extend : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Copy the bit sign as much as specified by the integer on the left</p></div></div><h2 id="infix-operators"><a href="#infix-operators" class="anchor"></a>Infix operators</h2><p>Divisions do not have any operators because signed and unsigned division have different semantics</p><div class="odoc-spec"><div class="spec value anchored" id="val-(+)"><a href="#val-(+)" class="anchor"></a><code><span><span class="keyword">val</span> (+) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-add"><code>add</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(-)"><a href="#val-(-)" class="anchor"></a><code><span><span class="keyword">val</span> (-) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-sub"><code>sub</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(*)"><a href="#val-(*)" class="anchor"></a><code><span><span class="keyword">val</span> (*) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-mul"><code>mul</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(~-)"><a href="#val-(~-)" class="anchor"></a><code><span><span class="keyword">val</span> (~-) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-neg"><code>neg</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(lsl)"><a href="#val-(lsl)" class="anchor"></a><code><span><span class="keyword">val</span> (lsl) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-shift_left_bv"><code>shift_left_bv</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-asl"><a href="#val-asl" class="anchor"></a><code><span><span class="keyword">val</span> asl : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-shift_left_bv"><code>shift_left_bv</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(lsr)"><a href="#val-(lsr)" class="anchor"></a><code><span><span class="keyword">val</span> (lsr) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-shift_right_logic_bv"><code>shift_right_logic_bv</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(asr)"><a href="#val-(asr)" class="anchor"></a><code><span><span class="keyword">val</span> (asr) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-shift_right_arith_bv"><code>shift_right_arith_bv</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lnot"><a href="#val-lnot" class="anchor"></a><code><span><span class="keyword">val</span> lnot : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-lognot"><code>lognot</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(land)"><a href="#val-(land)" class="anchor"></a><code><span><span class="keyword">val</span> (land) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-logand"><code>logand</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(lor)"><a href="#val-(lor)" class="anchor"></a><code><span><span class="keyword">val</span> (lor) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-logor"><code>logor</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(lxor)"><a href="#val-(lxor)" class="anchor"></a><code><span><span class="keyword">val</span> (lxor) : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><a href="#val-logxor"><code>logxor</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Bits/index.html b/doc/html/read-dwarf/Utils/Bits/index.html
index df597c86..6737becc 100644
--- a/doc/html/read-dwarf/Utils/Bits/index.html
+++ b/doc/html/read-dwarf/Utils/Bits/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Bits (read-dwarf.Utils.Bits)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Bits</nav><h1>Module <code>Utils.Bits</code></h1></header><aside><p>Like bytes, but for bit level manipulation. The underlying type is still bytes and thus the size has to be a multiple of 8.</p><p>The indexing is little endian: bit 9 is least significant bit of byte 1</p></aside><div class="spec module" id="module-Int"><a href="#module-Int" class="anchor"></a><code><span class="keyword">module</span> Int = <a href="../index.html#module-IntBits">IntBits</a></code></div><dl><dt class="spec value" id="val-check_index"><a href="#val-check_index" class="anchor"></a><code><span class="keyword">val</span> check_index : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p><code>check_index length i</code> Check that the index <code>i</code> is valid to index an bytes of length <code>length</code>. Throw <code>Invalid_argument</code> if not</p></dd></dl><dl><dt class="spec value" id="val-check_range"><a href="#val-check_range" class="anchor"></a><code><span class="keyword">val</span> check_range : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p><code>check_range length i l</code> Check that the range <code>[i;i+l)</code> is inside a bytes of length <code>length</code>. Throw <code>Invalid_argument</code> if not</p></dd></dl><dl><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : bytes <span>&#45;&gt;</span> int</code></dt><dd><p>Gives the length of a <code>bytes</code> in bits</p></dd></dl><dl><dt class="spec value" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> bytes</code></dt><dd><p>Create a <code>bytes</code> large enough to store the specified amount of bits</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bytes</code></dt><dd><p>Create a <code>bytes</code> large enough to store the specified amount of bits and initialize them as specified by the boolean</p></dd></dl><dl><dt class="spec value" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span class="keyword">val</span> unsafe_get : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Unsafe version of <a href="index.html#val-get"><code>get</code></a></p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Get a bit at a specific index. See <a href="index.html#val-unsafe_get"><code>unsafe_get</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span class="keyword">val</span> unsafe_set : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Unsafe version of <a href="index.html#val-set"><code>set</code></a></p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a bit at a specific index. See <a href="index.html#val-unsafe_set"><code>unsafe_set</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_clear"><a href="#val-unsafe_clear" class="anchor"></a><code><span class="keyword">val</span> unsafe_clear : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Unsafe version of <a href="index.html#val-clear"><code>clear</code></a></p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear a bit at a specific index. See <a href="index.html#val-unsafe_clear"><code>unsafe_clear</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_setb"><a href="#val-unsafe_setb" class="anchor"></a><code><span class="keyword">val</span> unsafe_setb : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> unit</code></dt><dd><p>Unsafe version of <a href="index.html#val-setb"><code>setb</code></a></p></dd></dl><dl><dt class="spec value" id="val-setb"><a href="#val-setb" class="anchor"></a><code><span class="keyword">val</span> setb : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a bit at a specific index according to a boolean. See <a href="index.html#val-unsafe_setb"><code>unsafe_setb</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_blit_to_int"><a href="#val-unsafe_blit_to_int" class="anchor"></a><code><span class="keyword">val</span> unsafe_blit_to_int : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../IntBits/index.html#type-t">Int.t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../IntBits/index.html#type-t">Int.t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-blit_to_int"><code>blit_to_int</code></a></p></dd></dl><dl><dt class="spec value" id="val-blit_to_int"><a href="#val-blit_to_int" class="anchor"></a><code><span class="keyword">val</span> blit_to_int : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../IntBits/index.html#type-t">Int.t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../IntBits/index.html#type-t">Int.t</a></code></dt><dd><p><code>blit_to_int src isrc dest idest len</code> blits the bits in range <code>[isrc;isrc+len)</code> of <code>src</code> to the range <code>[idest;idest + len)</code> of <code>dest</code> and returns the result. See <a href="index.html#val-unsafe_blit_to_int"><code>unsafe_blit_to_int</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-unsafe_blit_of_int"><a href="#val-unsafe_blit_of_int" class="anchor"></a><code><span class="keyword">val</span> unsafe_blit_of_int : <a href="../IntBits/index.html#type-t">Int.t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Unsafe version of <a href="index.html#val-blit_of_int"><code>blit_of_int</code></a></p></dd></dl><dl><dt class="spec value" id="val-blit_of_int"><a href="#val-blit_of_int" class="anchor"></a><code><span class="keyword">val</span> blit_of_int : <a href="../IntBits/index.html#type-t">Int.t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p><code>blit_of_int src isrc dest idest len</code> blits the bits in range <code>[isrc;isrc+len)</code> or src to the range <code>[idest;idest + len)</code> of dest by mutation. See <a href="index.html#val-unsafe_blit_of_int"><code>unsafe_blit_of_int</code></a>.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Bits (read-dwarf.Utils.Bits)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Bits</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Bits</span></code></h1><p>Like bytes, but for bit level manipulation. The underlying type is still bytes and thus the size has to be a multiple of 8.</p><p>The indexing is little endian: bit 9 is least significant bit of byte 1</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Int"><a href="#module-Int" class="anchor"></a><code><span><span class="keyword">module</span> Int</span><span> = <a href="../IntBits/index.html">IntBits</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_index"><a href="#val-check_index" class="anchor"></a><code><span><span class="keyword">val</span> check_index : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p><code>check_index length i</code> Check that the index <code>i</code> is valid to index an bytes of length <code>length</code>. Throw <code>Invalid_argument</code> if not</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_range"><a href="#val-check_range" class="anchor"></a><code><span><span class="keyword">val</span> check_range : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p><code>check_range length i l</code> Check that the range <code>[i;i+l)</code> is inside a bytes of length <code>length</code>. Throw <code>Invalid_argument</code> if not</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span>bytes <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Gives the length of a <code>bytes</code> in bits</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div><div class="spec-doc"><p>Create a <code>bytes</code> large enough to store the specified amount of bits</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div><div class="spec-doc"><p>Create a <code>bytes</code> large enough to store the specified amount of bits and initialize them as specified by the boolean</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_get : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-get"><code>get</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Get a bit at a specific index. See <a href="#val-unsafe_get"><code>unsafe_get</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_set : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-set"><code>set</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a bit at a specific index. See <a href="#val-unsafe_set"><code>unsafe_set</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_clear"><a href="#val-unsafe_clear" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_clear : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-clear"><code>clear</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear a bit at a specific index. See <a href="#val-unsafe_clear"><code>unsafe_clear</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_setb"><a href="#val-unsafe_setb" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_setb : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-setb"><code>setb</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-setb"><a href="#val-setb" class="anchor"></a><code><span><span class="keyword">val</span> setb : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a bit at a specific index according to a boolean. See <a href="#val-unsafe_setb"><code>unsafe_setb</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_blit_to_int"><a href="#val-unsafe_blit_to_int" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_blit_to_int : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../IntBits/index.html#type-t">Int.t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../IntBits/index.html#type-t">Int.t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-blit_to_int"><code>blit_to_int</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit_to_int"><a href="#val-blit_to_int" class="anchor"></a><code><span><span class="keyword">val</span> blit_to_int : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="../IntBits/index.html#type-t">Int.t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../IntBits/index.html#type-t">Int.t</a></span></code></div><div class="spec-doc"><p><code>blit_to_int src isrc dest idest len</code> blits the bits in range <code>[isrc;isrc+len)</code> of <code>src</code> to the range <code>[idest;idest + len)</code> of <code>dest</code> and returns the result. See <a href="#val-unsafe_blit_to_int"><code>unsafe_blit_to_int</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_blit_of_int"><a href="#val-unsafe_blit_of_int" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_blit_of_int : <span><a href="../IntBits/index.html#type-t">Int.t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-blit_of_int"><code>blit_of_int</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit_of_int"><a href="#val-blit_of_int" class="anchor"></a><code><span><span class="keyword">val</span> blit_of_int : <span><a href="../IntBits/index.html#type-t">Int.t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p><code>blit_of_int src isrc dest idest len</code> blits the bits in range <code>[isrc;isrc+len)</code> or src to the range <code>[idest;idest + len)</code> of dest by mutation. See <a href="#val-unsafe_blit_of_int"><code>unsafe_blit_of_int</code></a>.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/BytesSeq/index.html b/doc/html/read-dwarf/Utils/BytesSeq/index.html
index a08e6fe0..95a6910d 100644
--- a/doc/html/read-dwarf/Utils/BytesSeq/index.html
+++ b/doc/html/read-dwarf/Utils/BytesSeq/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BytesSeq (read-dwarf.Utils.BytesSeq)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; BytesSeq</nav><h1>Module <code>Utils.BytesSeq</code></h1><nav class="toc"><ul><li><a href="#hexadecimal-conversions">Hexadecimal conversions</a></li><li><a href="#cutting-the-view">Cutting the view</a></li><li><a href="#interaction-with-bytes-and-raw-string">Interaction with <code>bytes</code> and raw string</a></li><li><a href="#array-conversions">Array conversions</a></li><li><a href="#getters">Getters</a></li><li><a href="#iterators">Iterators</a></li><li><a href="#list-conversions">List conversions</a></li><li><a href="#binary-io">Binary IO</a></li><li><a href="#pretty-printing">Pretty Printing</a></li></ul></nav></header><aside><p>This module represent a byte sub view on a <code>bytes</code> object. Contrary to <code>Bytes</code> it is a non-owning immutable view. It do not prevent the original bytes from being modified, and the changes will be propagated in the view. It is additional sugar on top of Linksem's <code>Byte_sequence_wrapper</code></p><p>About all the suffixed function:</p><ul><li>All iteration function without suffix do the expected operation on char (as single bytes)</li><li>All iteration function with suffix nle do the expected operation on a sequence of integers of n bits as read in little endian.</li><li>All iteration function with suffix nbe do the expected operation on a sequence of integers of n bits as read in big endian.</li><li>All iteration function with suffix bs do the expected operation on a sequence of BytesSeq.t of specified length.</li><li>All iteration function with suffix bvle do the expected operation on a sequence of <a href="../BitVec/index.html"><code>BitVec</code></a> the specified <code>size</code> as read in little endian.</li></ul></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = Byte_sequence_wrapper.byte_sequence</code></dt><dd><p>Type inherited from <code>linksem</code></p></dd></dl><dl><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the length of the byteseq in bytes</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if two byte sequence are equal byte for byte</p></dd></dl><dl><dt class="spec value" id="val-int_bytes"><a href="#val-int_bytes" class="anchor"></a><code><span class="keyword">val</span> int_bytes : int</code></dt><dd><p>The size in bytes of an Ocaml int</p></dd></dl><section><header><h2 id="hexadecimal-conversions"><a href="#hexadecimal-conversions" class="anchor"></a>Hexadecimal conversions</h2></header><dl><dt class="spec value" id="val-to_hex"><a href="#val-to_hex" class="anchor"></a><code><span class="keyword">val</span> to_hex : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert the byte sequence to an hexadecimal string</p></dd></dl><dl><dt class="spec value" id="val-to_hex_rev"><a href="#val-to_hex_rev" class="anchor"></a><code><span class="keyword">val</span> to_hex_rev : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert the byte sequence to an reversed hexadecimal string. This will print it like a big-endian integer.</p></dd></dl><dl><dt class="spec value" id="val-of_hex"><a href="#val-of_hex" class="anchor"></a><code><span class="keyword">val</span> of_hex : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Parse the string as hexadecimal like A4B767DF and create a bytes of this a binary data and then a bytesSeq view of it</p></dd></dl></section><section><header><h2 id="cutting-the-view"><a href="#cutting-the-view" class="anchor"></a>Cutting the view</h2></header><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>sub bs start len</code> Extract a sub range <code>[start:start+len)</code> of a byte sequence. This is O(1)</p></dd></dl><dl><dt class="spec value" id="val-front"><a href="#val-front" class="anchor"></a><code><span class="keyword">val</span> front : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>front i bs</code> Take the first <code>i</code> bytes of <code>bs</code> and discard the rest. Equivalent to <code>sub bs 0 i</code></p></dd></dl><dl><dt class="spec value" id="val-back"><a href="#val-back" class="anchor"></a><code><span class="keyword">val</span> back : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>back i bs</code> Take the last <code>i</code> bytes of <code>bs</code> and discard the rest. Equivalent to <code>sub bs i (length bs - i)</code></p></dd></dl></section><section><header><h2 id="interaction-with-bytes-and-raw-string"><a href="#interaction-with-bytes-and-raw-string" class="anchor"></a>Interaction with <code>bytes</code> and raw string</h2></header><dl><dt class="spec value" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span class="keyword">val</span> blit : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p><code>blit src srcoff dst dstoff len</code> copies <code>len</code> bytes from bytes sequence <code>src</code>, starting at index <code>srcoff</code>, to bytes <code>dst</code>, starting at index <code>dstoff</code>.</p><p>See <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Bytes.html#VALblit"><code>Bytes.blit</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span class="keyword">val</span> of_bytes : bytes <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a view of the whole bytes</p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a view of the whole string as raw bytes</p></dd></dl><dl><dt class="spec value" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span class="keyword">val</span> to_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Create a copy of the view in a string</p></dd></dl><dl><dt class="spec value" id="val-bytes_sub"><a href="#val-bytes_sub" class="anchor"></a><code><span class="keyword">val</span> bytes_sub : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Create a byte sequence view of a specified range of a bytes. See <a href="index.html#val-sub"><code>sub</code></a></p></dd></dl></section><section><header><h2 id="array-conversions"><a href="#array-conversions" class="anchor"></a>Array conversions</h2></header><dl><dt class="spec value" id="val-to_array"><a href="#val-to_array" class="anchor"></a><code><span class="keyword">val</span> to_array : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>char array</span></code></dt><dd><p>Convert to a char array</p></dd></dl><dl><dt class="spec value" id="val-of_array"><a href="#val-of_array" class="anchor"></a><code><span class="keyword">val</span> of_array : <span>char array</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Convert from a char array</p></dd></dl></section><section><header><h2 id="getters"><a href="#getters" class="anchor"></a>Getters</h2></header><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char</code></dt><dd><p>Get the bytes at the offset in the byte sequence</p></dd></dl><dl><dt class="spec value" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span class="keyword">val</span> unsafe_get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char</code></dt><dd><p>Unsafe version of <a href="index.html#val-get"><code>get</code></a></p></dd></dl><dl><dt class="spec value" id="val-get16le"><a href="#val-get16le" class="anchor"></a><code><span class="keyword">val</span> get16le : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int</code></dt><dd><p>Get a 16 bit integer at the offset in the byte sequence as little endian</p></dd></dl><dl><dt class="spec value" id="val-get16be"><a href="#val-get16be" class="anchor"></a><code><span class="keyword">val</span> get16be : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int</code></dt><dd><p>Get a 16 bit integer at the offset in the byte sequence as big endian</p></dd></dl><dl><dt class="spec value" id="val-get32le"><a href="#val-get32le" class="anchor"></a><code><span class="keyword">val</span> get32le : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int32</code></dt><dd><p>Get a 32 bit integer at the offset in the byte sequence as little endian</p></dd></dl><dl><dt class="spec value" id="val-get32be"><a href="#val-get32be" class="anchor"></a><code><span class="keyword">val</span> get32be : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int32</code></dt><dd><p>Get a 32 bit integer at the offset in the byte sequence as big endian</p></dd></dl><dl><dt class="spec value" id="val-get64le"><a href="#val-get64le" class="anchor"></a><code><span class="keyword">val</span> get64le : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int64</code></dt><dd><p>Get a 64 bit integer at the offset in the byte sequence as little endian</p></dd></dl><dl><dt class="spec value" id="val-get64be"><a href="#val-get64be" class="anchor"></a><code><span class="keyword">val</span> get64be : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int64</code></dt><dd><p>Get a 64 bit integer at the offset in the byte sequence as big endian</p></dd></dl><dl><dt class="spec value" id="val-getintle"><a href="#val-getintle" class="anchor"></a><code><span class="keyword">val</span> getintle : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int</code></dt><dd><p>Get an Ocaml int at the offset in the byte sequence as little endian. The number of bytes read is 4 if <code>Sys.int_size</code> is 31 and 8 if <code>Sys.int_size</code> is 63</p></dd></dl><dl><dt class="spec value" id="val-getbs"><a href="#val-getbs" class="anchor"></a><code><span class="keyword">val</span> getbs : <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get a byte sequence of length <code>len</code> at the offset in another byte sequence</p></dd></dl><dl><dt class="spec value" id="val-getbvle"><a href="#val-getbvle" class="anchor"></a><code><span class="keyword">val</span> getbvle : <span>size:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="../BitVec/index.html#type-t">BitVec.t</a></code></dt><dd><p>Get a <a href="../BitVec/index.html"><code>BitVec</code></a> of size <code>size</code> at the offset in the byte sequence as little endian</p></dd></dl><dl><dt class="spec value" id="val-getintle_ze"><a href="#val-getintle_ze" class="anchor"></a><code><span class="keyword">val</span> getintle_ze : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int</code></dt><dd><p>Get an Ocaml int at the offset in the byte sequence as little endian. The number of bytes read is 4 if <code>Sys.int_size</code> is 31 and 8 if <code>Sys.int_size</code> is 63. If the read goes beyond the end of the sequence, instead of failing, zeros are read.</p></dd></dl></section><section><header><h2 id="iterators"><a href="#iterators" class="anchor"></a>Iterators</h2><p>Iterators over a byte sequence. If the length of the byte sequence is not a multiple of the step of the iteration then the trailing odd bytes are not iterated over.</p></header><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(char <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter16le"><a href="#val-iter16le" class="anchor"></a><code><span class="keyword">val</span> iter16le : <span>(int <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter16be"><a href="#val-iter16be" class="anchor"></a><code><span class="keyword">val</span> iter16be : <span>(int <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter32le"><a href="#val-iter32le" class="anchor"></a><code><span class="keyword">val</span> iter32le : <span>(int32 <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter32be"><a href="#val-iter32be" class="anchor"></a><code><span class="keyword">val</span> iter32be : <span>(int32 <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter64le"><a href="#val-iter64le" class="anchor"></a><code><span class="keyword">val</span> iter64le : <span>(int64 <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter64be"><a href="#val-iter64be" class="anchor"></a><code><span class="keyword">val</span> iter64be : <span>(int64 <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iterbs"><a href="#val-iterbs" class="anchor"></a><code><span class="keyword">val</span> iterbs : <span>len:int</span> <span>&#45;&gt;</span> <span>(<a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterate over the byte sequence by bytesequence of length <code>len</code>. If the total byte sequence is not of length a multiple of <code>len</code> then that iterated value will be shorter</p></dd></dl><dl><dt class="spec value" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span class="keyword">val</span> fold_left : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> char <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_left16le"><a href="#val-fold_left16le" class="anchor"></a><code><span class="keyword">val</span> fold_left16le : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_left16be"><a href="#val-fold_left16be" class="anchor"></a><code><span class="keyword">val</span> fold_left16be : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_left32le"><a href="#val-fold_left32le" class="anchor"></a><code><span class="keyword">val</span> fold_left32le : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int32 <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_left32be"><a href="#val-fold_left32be" class="anchor"></a><code><span class="keyword">val</span> fold_left32be : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int32 <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_left64le"><a href="#val-fold_left64le" class="anchor"></a><code><span class="keyword">val</span> fold_left64le : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int64 <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_left64be"><a href="#val-fold_left64be" class="anchor"></a><code><span class="keyword">val</span> fold_left64be : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int64 <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_leftbs"><a href="#val-fold_leftbs" class="anchor"></a><code><span class="keyword">val</span> fold_leftbs : <span>len:int</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl></section><section><header><h2 id="list-conversions"><a href="#list-conversions" class="anchor"></a>List conversions</h2></header><dl><dt class="spec value" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span class="keyword">val</span> to_list : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>char list</span></code></dt><dt class="spec value" id="val-to_list16le"><a href="#val-to_list16le" class="anchor"></a><code><span class="keyword">val</span> to_list16le : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>int list</span></code></dt><dt class="spec value" id="val-to_list16be"><a href="#val-to_list16be" class="anchor"></a><code><span class="keyword">val</span> to_list16be : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>int list</span></code></dt><dt class="spec value" id="val-to_list32le"><a href="#val-to_list32le" class="anchor"></a><code><span class="keyword">val</span> to_list32le : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>int32 list</span></code></dt><dt class="spec value" id="val-to_list32be"><a href="#val-to_list32be" class="anchor"></a><code><span class="keyword">val</span> to_list32be : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>int32 list</span></code></dt><dt class="spec value" id="val-to_list64le"><a href="#val-to_list64le" class="anchor"></a><code><span class="keyword">val</span> to_list64le : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>int64 list</span></code></dt><dt class="spec value" id="val-to_list64be"><a href="#val-to_list64be" class="anchor"></a><code><span class="keyword">val</span> to_list64be : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>int64 list</span></code></dt><dt class="spec value" id="val-to_listbs"><a href="#val-to_listbs" class="anchor"></a><code><span class="keyword">val</span> to_listbs : <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-t">t</a> list</span></code></dt><dd><p>Cut a byte sequence into a list of byte sequences of length <code>len</code>, (and a shorter last one if the total len is not a multiple of len)</p></dd></dl></section><section><header><h2 id="binary-io"><a href="#binary-io" class="anchor"></a>Binary IO</h2></header><dl><dt class="spec value" id="val-output"><a href="#val-output" class="anchor"></a><code><span class="keyword">val</span> output : Stdlib.out_channel <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Output the raw data of the byte sequence on the output channel</p></dd></dl><dl><dt class="spec value" id="val-input"><a href="#val-input" class="anchor"></a><code><span class="keyword">val</span> input : Stdlib.in_channel <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Output the raw date of the byte sequence of the input channel</p></dd></dl></section><section><header><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty Printing</h2></header><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a byte sequence as space separated bytes like <code>ab cd ef</code>.</p><p>Here &quot;ab&quot; is the byte number 0 and &quot;ef&quot; is the byte number 2.</p></dd></dl><dl><dt class="spec value" id="val-ppc"><a href="#val-ppc" class="anchor"></a><code><span class="keyword">val</span> ppc : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a byte sequence as an hexadecimal string like <code>abcdef</code></p><p>Here &quot;ab&quot; is the byte number 0 and &quot;ef&quot; is the byte number 2.</p><p>This can also be seen as printing the bytesequence as a single integer encoded in big endian format.</p></dd></dl><dl><dt class="spec value" id="val-ppint"><a href="#val-ppint" class="anchor"></a><code><span class="keyword">val</span> ppint : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a byte sequence as an hexadecimal integer (in little endian). The byte order is reversed compared to <a href="index.html#val-ppc"><code>ppc</code></a></p><p>For example the byte sequence <code>ab cd ef</code> will be printed as <code>efcdab</code> where &quot;ab&quot; is the byte number 0 and &quot;ef&quot; is the byte number 2.</p></dd></dl><dl><dt class="spec value" id="val-ppby"><a href="#val-ppby" class="anchor"></a><code><span class="keyword">val</span> ppby : <span>by:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a byte sequence by step of <code>by</code> bytes. Each block is pretty printed as an hex string like <a href="index.html#val-ppc"><code>ppc</code></a> and blocks are separated by spaces.</p></dd></dl><dl><dt class="spec value" id="val-ppbyint"><a href="#val-ppbyint" class="anchor"></a><code><span class="keyword">val</span> ppbyint : <span>by:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a byte sequence by step of <code>by</code> bytes. Each block is pretty printed as a reversed hex string i.e like an integer of length <code>by</code>. Thus each block will printed like with <code>ppcint</code> Blocks are separated by spaces.</p><p>For example to print a byte sequence as a space separated list of little-endian integers do:</p><pre><code class="ml">ppbyint ~by:4 bs</code></pre></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>BytesSeq (read-dwarf.Utils.BytesSeq)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; BytesSeq</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.BytesSeq</span></code></h1><p>This module represent a byte sub view on a <code>bytes</code> object. Contrary to <code>Bytes</code> it is a non-owning immutable view. It do not prevent the original bytes from being modified, and the changes will be propagated in the view. It is additional sugar on top of Linksem's <code>Byte_sequence_wrapper</code></p><p>About all the suffixed function:</p><ul><li>All iteration function without suffix do the expected operation on char (as single bytes)</li><li>All iteration function with suffix nle do the expected operation on a sequence of integers of n bits as read in little endian.</li><li>All iteration function with suffix nbe do the expected operation on a sequence of integers of n bits as read in big endian.</li><li>All iteration function with suffix bs do the expected operation on a sequence of BytesSeq.t of specified length.</li><li>All iteration function with suffix bvle do the expected operation on a sequence of <a href="../BitVec/index.html"><code>BitVec</code></a> the specified <code>size</code> as read in little endian.</li></ul></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#hexadecimal-conversions">Hexadecimal conversions</a></li><li><a href="#cutting-the-view">Cutting the view</a></li><li><a href="#interaction-with-bytes-and-raw-string">Interaction with <code>bytes</code> and raw string</a></li><li><a href="#array-conversions">Array conversions</a></li><li><a href="#getters">Getters</a></li><li><a href="#iterators">Iterators</a></li><li><a href="#list-conversions">List conversions</a></li><li><a href="#binary-io">Binary IO</a></li><li><a href="#pretty-printing">Pretty Printing</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <span class="xref-unresolved">Byte_sequence_wrapper</span>.byte_sequence</span></code></div><div class="spec-doc"><p>Type inherited from <code>linksem</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the length of the byteseq in bytes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if two byte sequence are equal byte for byte</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int_bytes"><a href="#val-int_bytes" class="anchor"></a><code><span><span class="keyword">val</span> int_bytes : int</span></code></div><div class="spec-doc"><p>The size in bytes of an Ocaml int</p></div></div><h2 id="hexadecimal-conversions"><a href="#hexadecimal-conversions" class="anchor"></a>Hexadecimal conversions</h2><div class="odoc-spec"><div class="spec value anchored" id="val-to_hex"><a href="#val-to_hex" class="anchor"></a><code><span><span class="keyword">val</span> to_hex : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert the byte sequence to an hexadecimal string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_hex_rev"><a href="#val-to_hex_rev" class="anchor"></a><code><span><span class="keyword">val</span> to_hex_rev : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert the byte sequence to an reversed hexadecimal string. This will print it like a big-endian integer.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_hex"><a href="#val-of_hex" class="anchor"></a><code><span><span class="keyword">val</span> of_hex : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Parse the string as hexadecimal like A4B767DF and create a bytes of this a binary data and then a bytesSeq view of it</p></div></div><h2 id="cutting-the-view"><a href="#cutting-the-view" class="anchor"></a>Cutting the view</h2><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>sub bs start len</code> Extract a sub range <code>[start:start+len)</code> of a byte sequence. This is O(1)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-front"><a href="#val-front" class="anchor"></a><code><span><span class="keyword">val</span> front : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>front i bs</code> Take the first <code>i</code> bytes of <code>bs</code> and discard the rest. Equivalent to <code>sub bs 0 i</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-back"><a href="#val-back" class="anchor"></a><code><span><span class="keyword">val</span> back : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>back i bs</code> Take the last <code>i</code> bytes of <code>bs</code> and discard the rest. Equivalent to <code>sub bs i (length bs - i)</code></p></div></div><h2 id="interaction-with-bytes-and-raw-string"><a href="#interaction-with-bytes-and-raw-string" class="anchor"></a>Interaction with <code>bytes</code> and raw string</h2><div class="odoc-spec"><div class="spec value anchored" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span><span class="keyword">val</span> blit : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p><code>blit src srcoff dst dstoff len</code> copies <code>len</code> bytes from bytes sequence <code>src</code>, starting at index <code>srcoff</code>, to bytes <code>dst</code>, starting at index <code>dstoff</code>.</p><p>See <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Bytes.html#VALblit"><code>Bytes.blit</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span><span class="keyword">val</span> of_bytes : <span>bytes <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a view of the whole bytes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a view of the whole string as raw bytes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_string"><a href="#val-to_string" class="anchor"></a><code><span><span class="keyword">val</span> to_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Create a copy of the view in a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bytes_sub"><a href="#val-bytes_sub" class="anchor"></a><code><span><span class="keyword">val</span> bytes_sub : <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Create a byte sequence view of a specified range of a bytes. See <a href="#val-sub"><code>sub</code></a></p></div></div><h2 id="array-conversions"><a href="#array-conversions" class="anchor"></a>Array conversions</h2><div class="odoc-spec"><div class="spec value anchored" id="val-to_array"><a href="#val-to_array" class="anchor"></a><code><span><span class="keyword">val</span> to_array : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>char array</span></span></code></div><div class="spec-doc"><p>Convert to a char array</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_array"><a href="#val-of_array" class="anchor"></a><code><span><span class="keyword">val</span> of_array : <span><span>char array</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Convert from a char array</p></div></div><h2 id="getters"><a href="#getters" class="anchor"></a>Getters</h2><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> char</span></code></div><div class="spec-doc"><p>Get the bytes at the offset in the byte sequence</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> char</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-get"><code>get</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get16le"><a href="#val-get16le" class="anchor"></a><code><span><span class="keyword">val</span> get16le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get a 16 bit integer at the offset in the byte sequence as little endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get16be"><a href="#val-get16be" class="anchor"></a><code><span><span class="keyword">val</span> get16be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get a 16 bit integer at the offset in the byte sequence as big endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get32le"><a href="#val-get32le" class="anchor"></a><code><span><span class="keyword">val</span> get32le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int32</span></code></div><div class="spec-doc"><p>Get a 32 bit integer at the offset in the byte sequence as little endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get32be"><a href="#val-get32be" class="anchor"></a><code><span><span class="keyword">val</span> get32be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int32</span></code></div><div class="spec-doc"><p>Get a 32 bit integer at the offset in the byte sequence as big endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get64le"><a href="#val-get64le" class="anchor"></a><code><span><span class="keyword">val</span> get64le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int64</span></code></div><div class="spec-doc"><p>Get a 64 bit integer at the offset in the byte sequence as little endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get64be"><a href="#val-get64be" class="anchor"></a><code><span><span class="keyword">val</span> get64be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int64</span></code></div><div class="spec-doc"><p>Get a 64 bit integer at the offset in the byte sequence as big endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-getintle"><a href="#val-getintle" class="anchor"></a><code><span><span class="keyword">val</span> getintle : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get an Ocaml int at the offset in the byte sequence as little endian. The number of bytes read is 4 if <code>Sys.int_size</code> is 31 and 8 if <code>Sys.int_size</code> is 63</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-getbs"><a href="#val-getbs" class="anchor"></a><code><span><span class="keyword">val</span> getbs : <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get a byte sequence of length <code>len</code> at the offset in another byte sequence</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-getbvle"><a href="#val-getbvle" class="anchor"></a><code><span><span class="keyword">val</span> getbvle : <span><span class="label">size</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="../BitVec/index.html#type-t">BitVec.t</a></span></code></div><div class="spec-doc"><p>Get a <a href="../BitVec/index.html"><code>BitVec</code></a> of size <code>size</code> at the offset in the byte sequence as little endian</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-getintle_ze"><a href="#val-getintle_ze" class="anchor"></a><code><span><span class="keyword">val</span> getintle_ze : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get an Ocaml int at the offset in the byte sequence as little endian. The number of bytes read is 4 if <code>Sys.int_size</code> is 31 and 8 if <code>Sys.int_size</code> is 63. If the read goes beyond the end of the sequence, instead of failing, zeros are read.</p></div></div><h2 id="iterators"><a href="#iterators" class="anchor"></a>Iterators</h2><p>Iterators over a byte sequence. If the length of the byte sequence is not a multiple of the step of the iteration then the trailing odd bytes are not iterated over.</p><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter16le"><a href="#val-iter16le" class="anchor"></a><code><span><span class="keyword">val</span> iter16le : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter16be"><a href="#val-iter16be" class="anchor"></a><code><span><span class="keyword">val</span> iter16be : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter32le"><a href="#val-iter32le" class="anchor"></a><code><span><span class="keyword">val</span> iter32le : <span><span>(<span>int32 <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter32be"><a href="#val-iter32be" class="anchor"></a><code><span><span class="keyword">val</span> iter32be : <span><span>(<span>int32 <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter64le"><a href="#val-iter64le" class="anchor"></a><code><span><span class="keyword">val</span> iter64le : <span><span>(<span>int64 <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter64be"><a href="#val-iter64be" class="anchor"></a><code><span><span class="keyword">val</span> iter64be : <span><span>(<span>int64 <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iterbs"><a href="#val-iterbs" class="anchor"></a><code><span><span class="keyword">val</span> iterbs : <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterate over the byte sequence by bytesequence of length <code>len</code>. If the total byte sequence is not of length a multiple of <code>len</code> then that iterated value will be shorter</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left16le"><a href="#val-fold_left16le" class="anchor"></a><code><span><span class="keyword">val</span> fold_left16le : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left16be"><a href="#val-fold_left16be" class="anchor"></a><code><span><span class="keyword">val</span> fold_left16be : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left32le"><a href="#val-fold_left32le" class="anchor"></a><code><span><span class="keyword">val</span> fold_left32le : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int32 <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left32be"><a href="#val-fold_left32be" class="anchor"></a><code><span><span class="keyword">val</span> fold_left32be : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int32 <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left64le"><a href="#val-fold_left64le" class="anchor"></a><code><span><span class="keyword">val</span> fold_left64le : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int64 <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left64be"><a href="#val-fold_left64be" class="anchor"></a><code><span><span class="keyword">val</span> fold_left64be : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int64 <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_leftbs"><a href="#val-fold_leftbs" class="anchor"></a><code><span><span class="keyword">val</span> fold_leftbs : <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><h2 id="list-conversions"><a href="#list-conversions" class="anchor"></a>List conversions</h2><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>char list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list16le"><a href="#val-to_list16le" class="anchor"></a><code><span><span class="keyword">val</span> to_list16le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list16be"><a href="#val-to_list16be" class="anchor"></a><code><span><span class="keyword">val</span> to_list16be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list32le"><a href="#val-to_list32le" class="anchor"></a><code><span><span class="keyword">val</span> to_list32le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int32 list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list32be"><a href="#val-to_list32be" class="anchor"></a><code><span><span class="keyword">val</span> to_list32be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int32 list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list64le"><a href="#val-to_list64le" class="anchor"></a><code><span><span class="keyword">val</span> to_list64le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int64 list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list64be"><a href="#val-to_list64be" class="anchor"></a><code><span><span class="keyword">val</span> to_list64be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int64 list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_listbs"><a href="#val-to_listbs" class="anchor"></a><code><span><span class="keyword">val</span> to_listbs : <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> list</span></span></code></div><div class="spec-doc"><p>Cut a byte sequence into a list of byte sequences of length <code>len</code>, (and a shorter last one if the total len is not a multiple of len)</p></div></div><h2 id="binary-io"><a href="#binary-io" class="anchor"></a>Binary IO</h2><div class="odoc-spec"><div class="spec value anchored" id="val-output"><a href="#val-output" class="anchor"></a><code><span><span class="keyword">val</span> output : <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Output the raw data of the byte sequence on the output channel</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input"><a href="#val-input" class="anchor"></a><code><span><span class="keyword">val</span> input : <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Output the raw date of the byte sequence of the input channel</p></div></div><h2 id="pretty-printing"><a href="#pretty-printing" class="anchor"></a>Pretty Printing</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a byte sequence as space separated bytes like <code>ab cd ef</code>.</p><p>Here &quot;ab&quot; is the byte number 0 and &quot;ef&quot; is the byte number 2.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppc"><a href="#val-ppc" class="anchor"></a><code><span><span class="keyword">val</span> ppc : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a byte sequence as an hexadecimal string like <code>abcdef</code></p><p>Here &quot;ab&quot; is the byte number 0 and &quot;ef&quot; is the byte number 2.</p><p>This can also be seen as printing the bytesequence as a single integer encoded in big endian format.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppint"><a href="#val-ppint" class="anchor"></a><code><span><span class="keyword">val</span> ppint : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a byte sequence as an hexadecimal integer (in little endian). The byte order is reversed compared to <a href="#val-ppc"><code>ppc</code></a></p><p>For example the byte sequence <code>ab cd ef</code> will be printed as <code>efcdab</code> where &quot;ab&quot; is the byte number 0 and &quot;ef&quot; is the byte number 2.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppby"><a href="#val-ppby" class="anchor"></a><code><span><span class="keyword">val</span> ppby : <span><span class="label">by</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a byte sequence by step of <code>by</code> bytes. Each block is pretty printed as an hex string like <a href="#val-ppc"><code>ppc</code></a> and blocks are separated by spaces.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppbyint"><a href="#val-ppbyint" class="anchor"></a><code><span><span class="keyword">val</span> ppbyint : <span><span class="label">by</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a byte sequence by step of <code>by</code> bytes. Each block is pretty printed as a reversed hex string i.e like an integer of length <code>by</code>. Thus each block will printed like with <code>ppcint</code> Blocks are separated by spaces.</p><p>For example to print a byte sequence as a space separated list of little-endian integers do:</p><pre class="language-ocaml"><code>ppbyint ~by:4 bs</code></pre></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Cache/index.html b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Cache/index.html
index 671ef87e..49e5b7ae 100644
--- a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Cache/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Cache/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Utils.Cache.Cmd.Test.Cache)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">Utils</a> &#x00BB; <a href="../../../index.html">Cache</a> &#x00BB; <a href="../../index.html">Cmd</a> &#x00BB; <a href="../index.html">Test</a> &#x00BB; Cache</nav><h1>Module <code>Test.Cache</code></h1></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="../index.html#module-Key">Key</a>.t</code></dt><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code><code> = <a href="../Value/index.html#type-t">Value.t</a></code></dt><dt class="spec type" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span class="keyword">type</span> epoch</code><code> = <a href="../../../UnitEpoch/index.html#type-t">UnitEpoch.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../Make/index.html#type-t">Make(Key)(Value)(UnitEpoch).t</a></code></dt><dd><p>The type that represent the cache in RAM.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-epoch">epoch</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a new cache management object with a name and an epoch If <code>fake</code> is set, the cache will not touch the disk and behave as a plain Hashtbl.</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dd><p>Get a value from the cache or <code>None</code> if no value is bound to the key</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dd><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add a new binding. Fails if a binding already exists</p></dd></dl><dl><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove a binding (Also delete the representation on disk</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Utils.Cache.Cmd.Test.Cache)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../../index.html">Index</a> &#x00BB; <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">Utils</a> &#x00BB; <a href="../../../index.html">Cache</a> &#x00BB; <a href="../../index.html">Cmd</a> &#x00BB; <a href="../index.html">Test</a> &#x00BB; Cache</nav><header class="odoc-preamble"><h1>Module <code><span>Test.Cache</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="../Key/index.html#type-t">Key.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span><span> = <a href="../Value/index.html#type-t">Value.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span><span class="keyword">type</span> epoch</span><span> = <a href="../../../UnitEpoch/index.html#type-t">UnitEpoch.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <a href="../../../Make/index.html#type-t">Make(Key)(Value)(UnitEpoch).t</a></span></code></div><div class="spec-doc"><p>The type that represent the cache in RAM.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-epoch">epoch</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a new cache management object with a name and an epoch If <code>fake</code> is set, the cache will not touch the disk and behave as a plain Hashtbl.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div><div class="spec-doc"><p>Get a value from the cache or <code>None</code> if no value is bound to the key</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div><div class="spec-doc"><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add a new binding. Fails if a binding already exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove a binding (Also delete the representation on disk</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Single/index.html b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Single/index.html
index 41175f38..9a900792 100644
--- a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Single/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Single/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Single (read-dwarf.Utils.Cache.Cmd.Test.Single)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">Utils</a> &#x00BB; <a href="../../../index.html">Cache</a> &#x00BB; <a href="../../index.html">Cmd</a> &#x00BB; <a href="../index.html">Test</a> &#x00BB; Single</nav><h1>Module <code>Test.Single</code></h1></header><dl><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code><code> = <a href="../Value/index.html#type-t">Value.t</a></code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../Single/index.html#type-t">Single(Value).t</a></code></dt><dd><p>The type that represent the cache in RAM.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a new cache management object with a name If <code>fake</code> is set, the cache will not touch the disk and behave as a plain ref.</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dd><p>Get a value from the cache or <code>None</code> if no value is stored</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dd><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the value in the cache</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear the value in the cache</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Single (read-dwarf.Utils.Cache.Cmd.Test.Single)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../../index.html">Index</a> &#x00BB; <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">Utils</a> &#x00BB; <a href="../../../index.html">Cache</a> &#x00BB; <a href="../../index.html">Cmd</a> &#x00BB; <a href="../index.html">Test</a> &#x00BB; Single</nav><header class="odoc-preamble"><h1>Module <code><span>Test.Single</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span><span> = <a href="../Value/index.html#type-t">Value.t</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <a href="../../../Single/index.html#type-t">Single(Value).t</a></span></code></div><div class="spec-doc"><p>The type that represent the cache in RAM.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a new cache management object with a name If <code>fake</code> is set, the cache will not touch the disk and behave as a plain ref.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div><div class="spec-doc"><p>Get a value from the cache or <code>None</code> if no value is stored</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div><div class="spec-doc"><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the value in the cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear the value in the cache</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Value/index.html b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Value/index.html
index a2d2255f..d0df6c3f 100644
--- a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Value/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/Value/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Utils.Cache.Cmd.Test.Value)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">Utils</a> &#x00BB; <a href="../../../index.html">Cache</a> &#x00BB; <a href="../../index.html">Cmd</a> &#x00BB; <a href="../index.html">Test</a> &#x00BB; Value</nav><h1>Module <code>Test.Value</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = string</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Serialize the value to a file</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the value back from a file. Must match with <a href="index.html#val-to_file"><code>to_file</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Utils.Cache.Cmd.Test.Value)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../../index.html">Index</a> &#x00BB; <a href="../../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../../index.html">Utils</a> &#x00BB; <a href="../../../index.html">Cache</a> &#x00BB; <a href="../../index.html">Cmd</a> &#x00BB; <a href="../index.html">Test</a> &#x00BB; Value</nav><header class="odoc-preamble"><h1>Module <code><span>Test.Value</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Serialize the value to a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the value back from a file. Must match with <a href="#val-to_file"><code>to_file</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/index.html b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/index.html
index 8a36a13e..84476414 100644
--- a/doc/html/read-dwarf/Utils/Cache/Cmd/Test/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Cmd/Test/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test (read-dwarf.Utils.Cache.Cmd.Test)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Cmd</a> &#x00BB; Test</nav><h1>Module <code>Cmd.Test</code></h1><p>This module provide a int -&gt; string cache for testing pruposes. It can be tested with <code>read-dwarf cache --test</code></p></header><div class="spec module" id="module-Key"><a href="#module-Key" class="anchor"></a><code><span class="keyword">module</span> Key : <a href="../../index.html#module-type-Key">Key</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../index.html#module-type-Key">Key</a>.t = int</code></div><div class="spec module" id="module-Value"><a href="#module-Value" class="anchor"></a><code><span class="keyword">module</span> <a href="Value/index.html">Value</a> : <a href="../../index.html#module-type-Value">Value</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../module-type-Value/index.html#type-t">t</a> = string</code></div><div class="spec module" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span class="keyword">module</span> <a href="Cache/index.html">Cache</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Single"><a href="#module-Single" class="anchor"></a><code><span class="keyword">module</span> <a href="Single/index.html">Single</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Test (read-dwarf.Utils.Cache.Cmd.Test)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Cmd</a> &#x00BB; Test</nav><header class="odoc-preamble"><h1>Module <code><span>Cmd.Test</span></code></h1><p>This module provide a int -&gt; string cache for testing pruposes. It can be tested with <code>read-dwarf cache --test</code></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Key"><a href="#module-Key" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Key/index.html">Key</a></span><span> : <a href="../../module-type-Key/index.html">Key</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../module-type-Key/index.html#type-t">t</a> = int</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Value"><a href="#module-Value" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Value/index.html">Value</a></span><span> : <a href="../../module-type-Value/index.html">Value</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../module-type-Value/index.html#type-t">t</a> = string</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cache/index.html">Cache</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Single"><a href="#module-Single" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Single/index.html">Single</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Cmd/index.html b/doc/html/read-dwarf/Utils/Cache/Cmd/index.html
index a8714815..54d09dfa 100644
--- a/doc/html/read-dwarf/Utils/Cache/Cmd/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Cmd/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cmd (read-dwarf.Utils.Cache.Cmd)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Cmd</nav><h1>Module <code>Cache.Cmd</code></h1><p>The cache command line. TODO documentation of the inside</p></header><dl><dt class="spec module" id="module-Test"><a href="#module-Test" class="anchor"></a><code><span class="keyword">module</span> <a href="Test/index.html">Test</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide a int -&gt; string cache for testing pruposes. It can be tested with <code>read-dwarf cache --test</code></p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-all"><a href="#val-all" class="anchor"></a><code><span class="keyword">val</span> all : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-test"><a href="#val-test" class="anchor"></a><code><span class="keyword">val</span> test : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-list"><a href="#val-list" class="anchor"></a><code><span class="keyword">val</span> list : <span>bool Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-arg"><a href="#val-arg" class="anchor"></a><code><span class="keyword">val</span> arg : <span><span>string option</span> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-fake"><a href="#val-fake" class="anchor"></a><code><span class="keyword">val</span> fake : <span>bool Cmdliner.Term.t</span></code></dt></dl><dl><dt class="spec type" id="type-operation"><a href="#type-operation" class="anchor"></a><code><span class="keyword">type</span> operation</code><code> = </code><table class="variant"><tr id="type-operation.CLEAR" class="anchored"><td class="def constructor"><a href="#type-operation.CLEAR" class="anchor"></a><code>| </code><code><span class="constructor">CLEAR</span></code></td></tr><tr id="type-operation.LIST" class="anchored"><td class="def constructor"><a href="#type-operation.LIST" class="anchor"></a><code>| </code><code><span class="constructor">LIST</span></code></td></tr><tr id="type-operation.TEST" class="anchored"><td class="def constructor"><a href="#type-operation.TEST" class="anchor"></a><code>| </code><code><span class="constructor">TEST</span></code></td></tr></table></dt><dd><p>The cache operataion to run</p></dd></dl><dl><dt class="spec value" id="val-op_f2m"><a href="#val-op_f2m" class="anchor"></a><code><span class="keyword">val</span> op_f2m : bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <span><a href="index.html#type-operation">operation</a> Cmdliner.Term.ret</span></code></dt><dd><p>Input flags to mode conversion</p></dd></dl><dl><dt class="spec value" id="val-operation_term"><a href="#val-operation_term" class="anchor"></a><code><span class="keyword">val</span> operation_term : <span><a href="index.html#type-operation">operation</a> Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-test"><a href="#val-test" class="anchor"></a><code><span class="keyword">val</span> test : bool <span>&#45;&gt;</span> unit</code></dt><dd><p>The testing mini command line to test the <a href="Test/index.html"><code>Test</code></a> cache</p></dd></dl><dl><dt class="spec value" id="val-dostuff"><a href="#val-dostuff" class="anchor"></a><code><span class="keyword">val</span> dostuff : <a href="index.html#type-operation">operation</a> <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <span>string option</span> <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> unit</code></dt><dd><p>Do the caching operation <code>op</code></p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt><dt class="spec value" id="val-exits"><a href="#val-exits" class="anchor"></a><code><span class="keyword">val</span> exits : <span>Cmdliner.Term.exit_info list</span></code></dt><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : Cmdliner.Term.info</code></dt><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>unit Cmdliner.Term.t</span> * Cmdliner.Term.info</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cmd (read-dwarf.Utils.Cache.Cmd)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Cmd</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.Cmd</span></code></h1><p>The cache command line. TODO documentation of the inside</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Test"><a href="#module-Test" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Test/index.html">Test</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a int -&gt; string cache for testing pruposes. It can be tested with <code>read-dwarf cache --test</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-all"><a href="#val-all" class="anchor"></a><code><span><span class="keyword">val</span> all : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-list"><a href="#val-list" class="anchor"></a><code><span><span class="keyword">val</span> list : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arg"><a href="#val-arg" class="anchor"></a><code><span><span class="keyword">val</span> arg : <span><span>string option</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fake"><a href="#val-fake" class="anchor"></a><code><span><span class="keyword">val</span> fake : <span>bool <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-operation"><a href="#type-operation" class="anchor"></a><code><span><span class="keyword">type</span> operation</span><span> = </span></code><ol><li id="type-operation.CLEAR" class="def variant constructor anchored"><a href="#type-operation.CLEAR" class="anchor"></a><code><span>| </span><span><span class="constructor">CLEAR</span></span></code></li><li id="type-operation.LIST" class="def variant constructor anchored"><a href="#type-operation.LIST" class="anchor"></a><code><span>| </span><span><span class="constructor">LIST</span></span></code></li><li id="type-operation.TEST" class="def variant constructor anchored"><a href="#type-operation.TEST" class="anchor"></a><code><span>| </span><span><span class="constructor">TEST</span></span></code></li></ol></div><div class="spec-doc"><p>The cache operataion to run</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-op_f2m"><a href="#val-op_f2m" class="anchor"></a><code><span><span class="keyword">val</span> op_f2m : <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-operation">operation</a> <span class="xref-unresolved">Cmdliner</span>.Term.ret</span></span></code></div><div class="spec-doc"><p>Input flags to mode conversion</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-operation_term"><a href="#val-operation_term" class="anchor"></a><code><span><span class="keyword">val</span> operation_term : <span><a href="#type-operation">operation</a> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-test"><a href="#val-test" class="anchor"></a><code><span><span class="keyword">val</span> test : <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>The testing mini command line to test the <a href="Test/index.html"><code>Test</code></a> cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dostuff"><a href="#val-dostuff" class="anchor"></a><code><span><span class="keyword">val</span> dostuff : <span><a href="#type-operation">operation</a> <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span>string option</span> <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Do the caching operation <code>op</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exits"><a href="#val-exits" class="anchor"></a><code><span><span class="keyword">val</span> exits : <span><span class="xref-unresolved">Cmdliner</span>.Cmd.Exit.info list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> * <span class="xref-unresolved">Cmdliner</span>.Cmd.info</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/IntEpoch/index.html b/doc/html/read-dwarf/Utils/Cache/IntEpoch/index.html
index a6cdcd57..1059dea7 100644
--- a/doc/html/read-dwarf/Utils/Cache/IntEpoch/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/IntEpoch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IntEpoch (read-dwarf.Utils.Cache.IntEpoch)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; IntEpoch</nav><h1>Module <code>Cache.IntEpoch</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = int</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span class="keyword">val</span> compat : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IntEpoch (read-dwarf.Utils.Cache.IntEpoch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; IntEpoch</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.IntEpoch</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span><span class="keyword">val</span> compat : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Make/argument-1-Key/index.html b/doc/html/read-dwarf/Utils/Cache/Make/argument-1-Key/index.html
index 6caebfa6..2a10c2cd 100644
--- a/doc/html/read-dwarf/Utils/Cache/Make/argument-1-Key/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Make/argument-1-Key/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Key (read-dwarf.Utils.Cache.Make.1-Key)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 1-Key</nav><h1>Parameter <code>Make.1-Key</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.Hashtbl.HashedType</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write the necessary information to retrieve the key in a file. The filename supplied is without the key extension. The implementer must call <a href="../../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : int <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build back the key from the hash and a storage file. The filename supplied is without the key extension. The implementer must call <a href="../../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it.</p><p>If you start with a <code>key</code> and a <code>file</code>, then doing <code>to_file file key</code> and then <code>of_file (hash key) file</code> must return something <a href="index.html#val-equal"><code>equal</code></a> to key.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Key (read-dwarf.Utils.Cache.Make.Key)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Key</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Key</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.HashedType</span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Write the necessary information to retrieve the key in a file. The filename supplied is without the key extension. The implementer must call <a href="../../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>int <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build back the key from the hash and a storage file. The filename supplied is without the key extension. The implementer must call <a href="../../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it.</p><p>If you start with a <code>key</code> and a <code>file</code>, then doing <code>to_file file key</code> and then <code>of_file (hash key) file</code> must return something <a href="#val-equal"><code>equal</code></a> to key.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Make/argument-2-Value/index.html b/doc/html/read-dwarf/Utils/Cache/Make/argument-2-Value/index.html
index 871cfeec..46723309 100644
--- a/doc/html/read-dwarf/Utils/Cache/Make/argument-2-Value/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Make/argument-2-Value/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>2-Value (read-dwarf.Utils.Cache.Make.2-Value)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 2-Value</nav><h1>Parameter <code>Make.2-Value</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Serialize the value to a file</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the value back from a file. Must match with <a href="index.html#val-to_file"><code>to_file</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Utils.Cache.Make.Value)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Value</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Value</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Serialize the value to a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the value back from a file. Must match with <a href="#val-to_file"><code>to_file</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Make/argument-3-Epoch/index.html b/doc/html/read-dwarf/Utils/Cache/Make/argument-3-Epoch/index.html
index fb9aa5d5..8f70d9ad 100644
--- a/doc/html/read-dwarf/Utils/Cache/Make/argument-3-Epoch/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Make/argument-3-Epoch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>3-Epoch (read-dwarf.Utils.Cache.Make.3-Epoch)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 3-Epoch</nav><h1>Parameter <code>Make.3-Epoch</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../index.html#module-type-Value">Value</a></code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Serialize the value to a file</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the value back from a file. Must match with <a href="index.html#val-to_file"><code>to_file</code></a></p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span class="keyword">val</span> compat : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tests if epochs are compatible</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Epoch (read-dwarf.Utils.Cache.Make.Epoch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Epoch</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Epoch</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../module-type-Value/index.html">Value</a></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Serialize the value to a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the value back from a file. Must match with <a href="#val-to_file"><code>to_file</code></a></p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span><span class="keyword">val</span> compat : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tests if epochs are compatible</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Make/index.html b/doc/html/read-dwarf/Utils/Cache/Make/index.html
index f911b0d3..704c629e 100644
--- a/doc/html/read-dwarf/Utils/Cache/Make/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Make/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Utils.Cache.Make)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Make</nav><h1>Module <code>Cache.Make</code></h1><p>The Key must provide the <a href="argument-1-Key/index.html"><code>Key</code></a> interface, where the values must satisfy the <a href="argument-2-Value/index.html"><code>Value</code></a> interface.</p><p>The map is stored on the disk in a simple way. First the key is hashed and this hashed gives a filename with <a href="../index.html#val-int_to_file"><code>int_to_file</code></a>. If there is no collision, then the value is stored in that file and the key is stored (optionally) in <code>hash.key</code> file (See <a href="argument-1-Key/index.html"><code>Key</code></a> for details).</p><p>If there is collision then the filename is a directory containing numbered files of all the key-value pairs. Again the value is in file named <code>n</code> when the key is (optionally) in file named <code>n.key</code>.</p></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Key/index.html">Key</a> : <a href="../index.html#module-type-Key">Key</a></code></li><li><code><a href="argument-2-Value/index.html">Value</a> : <a href="../index.html#module-type-Value">Value</a></code></li><li><code><a href="argument-3-Epoch/index.html">Epoch</a> : <a href="../index.html#module-type-Epoch">Epoch</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = <a href="index.html#argument-1-Key">Key</a>.t</code></dt><dd><p>The type of keys</p></dd></dl><dl><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code><code> = <a href="argument-2-Value/index.html#type-t">Value.t</a></code></dt><dd><p>The type of values</p></dd></dl><dl><dt class="spec type" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span class="keyword">type</span> epoch</code><code> = <a href="argument-3-Epoch/index.html#type-t">Epoch.t</a></code></dt><dd><p>The type of the epoch</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type that represent the cache in RAM.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-epoch">epoch</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a new cache management object with a name and an epoch If <code>fake</code> is set, the cache will not touch the disk and behave as a plain Hashtbl.</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dd><p>Get a value from the cache or <code>None</code> if no value is bound to the key</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dd><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add a new binding. Fails if a binding already exists</p></dd></dl><dl><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove a binding (Also delete the representation on disk</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Utils.Cache.Make)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Make</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.Make</span></code></h1><p>The Key must provide the <a href="../module-type-Key/index.html"><code>Key</code></a> interface, where the values must satisfy the <a href="../module-type-Value/index.html"><code>Value</code></a> interface.</p><p>The map is stored on the disk in a simple way. First the key is hashed and this hashed gives a filename with <a href="../index.html#val-int_to_file"><code>int_to_file</code></a>. If there is no collision, then the value is stored in that file and the key is stored (optionally) in <code>hash.key</code> file (See <a href="../module-type-Key/index.html"><code>Key</code></a> for details).</p><p>If there is collision then the filename is a directory containing numbered files of all the key-value pairs. Again the value is in file named <code>n</code> when the key is (optionally) in file named <code>n.key</code>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Key"><a href="#argument-1-Key" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Key/index.html">Key</a></span><span> : <a href="../module-type-Key/index.html">Key</a></span></code></div></div><div class="odoc-spec"><div class="spec parameter anchored" id="argument-2-Value"><a href="#argument-2-Value" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-2-Value/index.html">Value</a></span><span> : <a href="../module-type-Value/index.html">Value</a></span></code></div></div><div class="odoc-spec"><div class="spec parameter anchored" id="argument-3-Epoch"><a href="#argument-3-Epoch" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-3-Epoch/index.html">Epoch</a></span><span> : <a href="../module-type-Epoch/index.html">Epoch</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <a href="argument-1-Key/index.html#type-t">Key.t</a></span></code></div><div class="spec-doc"><p>The type of keys</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span><span> = <a href="argument-2-Value/index.html#type-t">Value.t</a></span></code></div><div class="spec-doc"><p>The type of values</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span><span class="keyword">type</span> epoch</span><span> = <a href="argument-3-Epoch/index.html#type-t">Epoch.t</a></span></code></div><div class="spec-doc"><p>The type of the epoch</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type that represent the cache in RAM.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-epoch">epoch</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a new cache management object with a name and an epoch If <code>fake</code> is set, the cache will not touch the disk and behave as a plain Hashtbl.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div><div class="spec-doc"><p>Get a value from the cache or <code>None</code> if no value is bound to the key</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div><div class="spec-doc"><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add a new binding. Fails if a binding already exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove a binding (Also delete the representation on disk</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Single/argument-1-Value/index.html b/doc/html/read-dwarf/Utils/Cache/Single/argument-1-Value/index.html
index 438dbf34..37238ef2 100644
--- a/doc/html/read-dwarf/Utils/Cache/Single/argument-1-Value/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Single/argument-1-Value/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Value (read-dwarf.Utils.Cache.Single.1-Value)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Single</a> &#x00BB; 1-Value</nav><h1>Parameter <code>Single.1-Value</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Serialize the value to a file</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the value back from a file. Must match with <a href="index.html#val-to_file"><code>to_file</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Utils.Cache.Single.Value)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Cache</a> &#x00BB; <a href="../index.html">Single</a> &#x00BB; Value</nav><header class="odoc-preamble"><h1>Parameter <code><span>Single.Value</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Serialize the value to a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the value back from a file. Must match with <a href="#val-to_file"><code>to_file</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/Single/index.html b/doc/html/read-dwarf/Utils/Cache/Single/index.html
index 3ed876fd..5dfc8667 100644
--- a/doc/html/read-dwarf/Utils/Cache/Single/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/Single/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Single (read-dwarf.Utils.Cache.Single)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Single</nav><h1>Module <code>Cache.Single</code></h1><p>The functor is to make a single cached value. This do not support epochs (Yet)</p><p>TODO: Maybe the code would be simpler if this was a map from unit to the value.</p></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Value/index.html">Value</a> : <a href="../index.html#module-type-Value">Value</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code><code> = <a href="argument-1-Value/index.html#type-t">Value.t</a></code></dt><dd><p>The type of the stored value</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type that represent the cache in RAM.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a new cache management object with a name If <code>fake</code> is set, the cache will not touch the disk and behave as a plain ref.</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dd><p>Get a value from the cache or <code>None</code> if no value is stored</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dd><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the value in the cache</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear the value in the cache</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Single (read-dwarf.Utils.Cache.Single)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Single</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.Single</span></code></h1><p>The functor is to make a single cached value. This do not support epochs (Yet)</p><p>TODO: Maybe the code would be simpler if this was a map from unit to the value.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Value"><a href="#argument-1-Value" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Value/index.html">Value</a></span><span> : <a href="../module-type-Value/index.html">Value</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span><span> = <a href="argument-1-Value/index.html#type-t">Value.t</a></span></code></div><div class="spec-doc"><p>The type of the stored value</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type that represent the cache in RAM.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a new cache management object with a name If <code>fake</code> is set, the cache will not touch the disk and behave as a plain ref.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div><div class="spec-doc"><p>Get a value from the cache or <code>None</code> if no value is stored</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div><div class="spec-doc"><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the value in the cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear the value in the cache</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/UnitEpoch/index.html b/doc/html/read-dwarf/Utils/Cache/UnitEpoch/index.html
index f66a8bd4..c2b2f68f 100644
--- a/doc/html/read-dwarf/Utils/Cache/UnitEpoch/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/UnitEpoch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>UnitEpoch (read-dwarf.Utils.Cache.UnitEpoch)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; UnitEpoch</nav><h1>Module <code>Cache.UnitEpoch</code></h1><p>A dummy epochs implementation, if not epoch is needed</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = unit</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : <span class="type-var">'a</span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span class="keyword">val</span> compat : unit <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> bool</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>UnitEpoch (read-dwarf.Utils.Cache.UnitEpoch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; UnitEpoch</nav><header class="odoc-preamble"><h1>Module <code><span>Cache.UnitEpoch</span></code></h1><p>A dummy epochs implementation, if not epoch is needed</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span><span class="keyword">val</span> compat : <span>unit <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/index.html b/doc/html/read-dwarf/Utils/Cache/index.html
index 83fbd0ed..65e2b6bb 100644
--- a/doc/html/read-dwarf/Utils/Cache/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Utils.Cache)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Cache</nav><h1>Module <code>Utils.Cache</code></h1><nav class="toc"><ul><li><a href="#utility">Utility</a></li><li><a href="#input-signatures">Input signatures</a></li><li><a href="#cachemap">CacheMap</a></li><li><a href="#single-cache">Single Cache</a></li><li><a href="#command-line-operations">Command line operations</a></li></ul></nav></header><aside><p>This module implement a caching system i.e a persistant structure stored on the disk.</p><p>A cache can be either:</p><ul><li>An associative map from keys to values, See <a href="Make/index.html"><code>Make</code></a></li><li>A single value, see <a href="Single/index.html"><code>Single</code></a></li></ul><p>A cache must be uniquely named and will be stored in <a href="index.html#val-find_dir"><code>find_dir</code></a><code>()/name</code>. This will be a directory in case of map and a file in case of a single value</p></aside><section><header><h2 id="utility"><a href="#utility" class="anchor"></a>Utility</h2><p>This section is not part of the external API, but creating an mli file here seemed needlessly annoying.</p></header><dl><dt class="spec value" id="val-base_dir"><a href="#val-base_dir" class="anchor"></a><code><span class="keyword">val</span> base_dir : string</code></dt><dd><p>The name of the read-dwarf cache. <code>.rdcache</code> for now.</p></dd></dl><dl><dt class="spec value" id="val-find_dir"><a href="#val-find_dir" class="anchor"></a><code><span class="keyword">val</span> find_dir : unit <span>&#45;&gt;</span> string</code></dt><dd><p>Find the current cache folder as described in the README.</p><p>When searching for a cache, this function will search if there already is a <a href="index.html#val-base_dir"><code>base_dir</code></a> directory either in the current directory or one of its parent and use the closest one it find. If it finds none and need a cache, it will create a new directory named <a href="index.html#val-base_dir"><code>base_dir</code></a> in the current directory. Therefore the returned directory always exists.</p></dd></dl><dl><dt class="spec value" id="val-removedir"><a href="#val-removedir" class="anchor"></a><code><span class="keyword">val</span> removedir : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove a directory and all it's content.</p><p>TODO: Make that Windows friendly</p><p>TODO move that in <a href="../Files/index.html"><code>Files</code></a></p></dd></dl><dl><dt class="spec value" id="val-cleardir"><a href="#val-cleardir" class="anchor"></a><code><span class="keyword">val</span> cleardir : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear the content of directory</p></dd></dl><dl><dt class="spec value" id="val-int_to_file"><a href="#val-int_to_file" class="anchor"></a><code><span class="keyword">val</span> int_to_file : int <span>&#45;&gt;</span> string</code></dt><dd><p>Convert an hash integer to a filename: 16 characters in hexadecimal</p></dd></dl><dl><dt class="spec type" id="type-file_type"><a href="#type-file_type" class="anchor"></a><code><span class="keyword">type</span> file_type</code><code> = </code><table class="variant"><tr id="type-file_type.NOPE" class="anchored"><td class="def constructor"><a href="#type-file_type.NOPE" class="anchor"></a><code>| </code><code><span class="constructor">NOPE</span></code></td></tr><tr id="type-file_type.FILE" class="anchored"><td class="def constructor"><a href="#type-file_type.FILE" class="anchor"></a><code>| </code><code><span class="constructor">FILE</span></code></td></tr><tr id="type-file_type.DIR" class="anchored"><td class="def constructor"><a href="#type-file_type.DIR" class="anchor"></a><code>| </code><code><span class="constructor">DIR</span> <span class="keyword">of</span> int</code></td></tr></table></dt><dd><p>The type of an entry at a given hash</p></dd></dl><dl><dt class="spec value" id="val-file_type"><a href="#val-file_type" class="anchor"></a><code><span class="keyword">val</span> file_type : string <span>&#45;&gt;</span> <a href="index.html#type-file_type">file_type</a></code></dt><dd><p>Give the file type of the given type. Do not count the number of entry in ther</p></dd></dl><dl><dt class="spec value" id="val-to_keyfile"><a href="#val-to_keyfile" class="anchor"></a><code><span class="keyword">val</span> to_keyfile : string <span>&#45;&gt;</span> string</code></dt><dd><p>Transform a filename in the key filename</p></dd></dl><dl><dt class="spec value" id="val-movekey"><a href="#val-movekey" class="anchor"></a><code><span class="keyword">val</span> movekey : string <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dd><p><code>movekey old new</code> moves a key correponding to the given filenames, if they exist</p></dd></dl><dl><dt class="spec value" id="val-removekey"><a href="#val-removekey" class="anchor"></a><code><span class="keyword">val</span> removekey : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Removes a key correponding to the given filename, if it exists</p></dd></dl><dl><dt class="spec value" id="val-clear_cache"><a href="#val-clear_cache" class="anchor"></a><code><span class="keyword">val</span> clear_cache : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Delete the supplied cache</p></dd></dl><dl><dt class="spec value" id="val-list_caches"><a href="#val-list_caches" class="anchor"></a><code><span class="keyword">val</span> list_caches : unit <span>&#45;&gt;</span> <span>string list</span></code></dt><dd><p>List all existing caches</p></dd></dl><dl><dt class="spec value" id="val-clear_all_caches"><a href="#val-clear_all_caches" class="anchor"></a><code><span class="keyword">val</span> clear_all_caches : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Delete all the caches (and the base cache directory)</p></dd></dl><dl><dt class="spec exception" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Exists</span></code></dt><dd><p>Thrown when adding a key that is already bound in cache</p></dd></dl></section><section><header><h2 id="input-signatures"><a href="#input-signatures" class="anchor"></a>Input signatures</h2></header><dl><dt class="spec module-type" id="module-type-Key"><a href="#module-type-Key" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Key/index.html">Key</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The interface of keys.</p></dd></dl><dl><dt class="spec module" id="module-IntKey"><a href="#module-IntKey" class="anchor"></a><code><span class="keyword">module</span> IntKey : <a href="index.html#module-type-Key">Key</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="index.html#module-type-Key">Key</a>.t = int</code></dt><dd><p>An implementation of <a href="module-type-Key/index.html"><code>Key</code></a> on ints where hash is the identity and no file is written</p></dd></dl><dl><dt class="spec module-type" id="module-type-Value"><a href="#module-type-Value" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Value/index.html">Value</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The interface of values: They just need to be able to be serialized to files. This is isn't plain Marshal because some values may want a human readable format.</p></dd></dl><dl><dt class="spec module-type" id="module-type-Epoch"><a href="#module-type-Epoch" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Epoch/index.html">Epoch</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>A cache can be indexed by an Epoch. When reading a cache with an incompatible epoch, then the cache is deleted on load. Use <a href="UnitEpoch/index.html"><code>UnitEpoch</code></a> to not have this functionality. <a href="Single/index.html"><code>Single</code></a> caches currently do not support epochs.</p></dd></dl><dl><dt class="spec module" id="module-UnitEpoch"><a href="#module-UnitEpoch" class="anchor"></a><code><span class="keyword">module</span> <a href="UnitEpoch/index.html">UnitEpoch</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>A dummy epochs implementation, if not epoch is needed</p></dd></dl><div class="spec module" id="module-IntEpoch"><a href="#module-IntEpoch" class="anchor"></a><code><span class="keyword">module</span> <a href="IntEpoch/index.html">IntEpoch</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div></section><section><header><h2 id="cachemap"><a href="#cachemap" class="anchor"></a>CacheMap</h2></header><dl><dt class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The output signature of <a href="Make/index.html"><code>Make</code></a></p></dd></dl><dl><dt class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span class="keyword">module</span> <a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-Key/index.html">Key</a> : <a href="index.html#module-type-Key">Key</a>) <span>&#45;&gt;</span> <span class="keyword">functor</span> (<a href="Make/argument-2-Value/index.html">Value</a> : <a href="index.html#module-type-Value">Value</a>) <span>&#45;&gt;</span> <span class="keyword">functor</span> (<a href="Make/argument-3-Epoch/index.html">Epoch</a> : <a href="index.html#module-type-Epoch">Epoch</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-S">S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="Make/index.html#type-key">key</a> = <a href="Make/index.html#argument-1-Key">Key</a>.t <span class="keyword">and</span> <span class="keyword">type</span> <a href="Make/index.html#type-value">value</a> = <a href="Make/argument-2-Value/index.html#type-t">Value.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="Make/index.html#type-epoch">epoch</a> = <a href="Make/argument-3-Epoch/index.html#type-t">Epoch.t</a></code></dt><dd><p>The Key must provide the <a href="Make/argument-1-Key/index.html"><code>Key</code></a> interface, where the values must satisfy the <a href="Make/argument-2-Value/index.html"><code>Value</code></a> interface.</p></dd></dl></section><section><header><h2 id="single-cache"><a href="#single-cache" class="anchor"></a>Single Cache</h2></header><dl><dt class="spec module-type" id="module-type-SingleS"><a href="#module-type-SingleS" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-SingleS/index.html">SingleS</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The signature of the output of <a href="Single/index.html"><code>Single</code></a></p></dd></dl><dl><dt class="spec module" id="module-Single"><a href="#module-Single" class="anchor"></a><code><span class="keyword">module</span> <a href="Single/index.html">Single</a> : <span class="keyword">functor</span> (<a href="Single/argument-1-Value/index.html">Value</a> : <a href="index.html#module-type-Value">Value</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-SingleS">SingleS</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="Single/index.html#type-value">value</a> = <a href="Single/argument-1-Value/index.html#type-t">Value.t</a></code></dt><dd><p>The functor is to make a single cached value. This do not support epochs (Yet)</p></dd></dl></section><section><header><h2 id="command-line-operations"><a href="#command-line-operations" class="anchor"></a>Command line operations</h2></header><dl><dt class="spec module" id="module-Cmd"><a href="#module-Cmd" class="anchor"></a><code><span class="keyword">module</span> <a href="Cmd/index.html">Cmd</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The cache command line. TODO documentation of the inside</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cache (read-dwarf.Utils.Cache)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Cache</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Cache</span></code></h1><p>This module implement a caching system i.e a persistant structure stored on the disk.</p><p>A cache can be either:</p><ul><li>An associative map from keys to values, See <a href="Make/index.html"><code>Make</code></a></li><li>A single value, see <a href="Single/index.html"><code>Single</code></a></li></ul><p>A cache must be uniquely named and will be stored in <a href="#val-find_dir"><code>find_dir</code></a><code>()/name</code>. This will be a directory in case of map and a file in case of a single value</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#utility">Utility</a></li><li><a href="#input-signatures">Input signatures</a></li><li><a href="#cachemap">CacheMap</a></li><li><a href="#single-cache">Single Cache</a></li><li><a href="#command-line-operations">Command line operations</a></li></ul></nav></div><div class="odoc-content"><h2 id="utility"><a href="#utility" class="anchor"></a>Utility</h2><p>This section is not part of the external API, but creating an mli file here seemed needlessly annoying.</p><div class="odoc-spec"><div class="spec value anchored" id="val-base_dir"><a href="#val-base_dir" class="anchor"></a><code><span><span class="keyword">val</span> base_dir : string</span></code></div><div class="spec-doc"><p>The name of the read-dwarf cache. <code>.rdcache</code> for now.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_dir"><a href="#val-find_dir" class="anchor"></a><code><span><span class="keyword">val</span> find_dir : <span>unit <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Find the current cache folder as described in the README.</p><p>When searching for a cache, this function will search if there already is a <a href="#val-base_dir"><code>base_dir</code></a> directory either in the current directory or one of its parent and use the closest one it find. If it finds none and need a cache, it will create a new directory named <a href="#val-base_dir"><code>base_dir</code></a> in the current directory. Therefore the returned directory always exists.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-removedir"><a href="#val-removedir" class="anchor"></a><code><span><span class="keyword">val</span> removedir : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove a directory and all it's content.</p><p>TODO: Make that Windows friendly</p><p>TODO move that in <a href="../Files/index.html"><code>Files</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cleardir"><a href="#val-cleardir" class="anchor"></a><code><span><span class="keyword">val</span> cleardir : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear the content of directory</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int_to_file"><a href="#val-int_to_file" class="anchor"></a><code><span><span class="keyword">val</span> int_to_file : <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert an hash integer to a filename: 16 characters in hexadecimal</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-file_type"><a href="#type-file_type" class="anchor"></a><code><span><span class="keyword">type</span> file_type</span><span> = </span></code><ol><li id="type-file_type.NOPE" class="def variant constructor anchored"><a href="#type-file_type.NOPE" class="anchor"></a><code><span>| </span><span><span class="constructor">NOPE</span></span></code></li><li id="type-file_type.FILE" class="def variant constructor anchored"><a href="#type-file_type.FILE" class="anchor"></a><code><span>| </span><span><span class="constructor">FILE</span></span></code></li><li id="type-file_type.DIR" class="def variant constructor anchored"><a href="#type-file_type.DIR" class="anchor"></a><code><span>| </span><span><span class="constructor">DIR</span> <span class="keyword">of</span> int</span></code></li></ol></div><div class="spec-doc"><p>The type of an entry at a given hash</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-file_type"><a href="#val-file_type" class="anchor"></a><code><span><span class="keyword">val</span> file_type : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-file_type">file_type</a></span></code></div><div class="spec-doc"><p>Give the file type of the given type. Do not count the number of entry in ther</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_keyfile"><a href="#val-to_keyfile" class="anchor"></a><code><span><span class="keyword">val</span> to_keyfile : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Transform a filename in the key filename</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-movekey"><a href="#val-movekey" class="anchor"></a><code><span><span class="keyword">val</span> movekey : <span>string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p><code>movekey old new</code> moves a key correponding to the given filenames, if they exist</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-removekey"><a href="#val-removekey" class="anchor"></a><code><span><span class="keyword">val</span> removekey : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Removes a key correponding to the given filename, if it exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_cache"><a href="#val-clear_cache" class="anchor"></a><code><span><span class="keyword">val</span> clear_cache : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Delete the supplied cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-list_caches"><a href="#val-list_caches" class="anchor"></a><code><span><span class="keyword">val</span> list_caches : <span>unit <span class="arrow">&#45;&gt;</span></span> <span>string list</span></span></code></div><div class="spec-doc"><p>List all existing caches</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_all_caches"><a href="#val-clear_all_caches" class="anchor"></a><code><span><span class="keyword">val</span> clear_all_caches : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Delete all the caches (and the base cache directory)</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Exists</span></span></code></div><div class="spec-doc"><p>Thrown when adding a key that is already bound in cache</p></div></div><h2 id="input-signatures"><a href="#input-signatures" class="anchor"></a>Input signatures</h2><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-Key"><a href="#module-type-Key" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Key/index.html">Key</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The interface of keys.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-IntKey"><a href="#module-IntKey" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IntKey/index.html">IntKey</a></span><span> : <a href="module-type-Key/index.html">Key</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-Key/index.html#type-t">t</a> = int</span></span></code></div><div class="spec-doc"><p>An implementation of <a href="module-type-Key/index.html"><code>Key</code></a> on ints where hash is the identity and no file is written</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-Value"><a href="#module-type-Value" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Value/index.html">Value</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The interface of values: They just need to be able to be serialized to files. This is isn't plain Marshal because some values may want a human readable format.</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-Epoch"><a href="#module-type-Epoch" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Epoch/index.html">Epoch</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A cache can be indexed by an Epoch. When reading a cache with an incompatible epoch, then the cache is deleted on load. Use <a href="UnitEpoch/index.html"><code>UnitEpoch</code></a> to not have this functionality. <a href="Single/index.html"><code>Single</code></a> caches currently do not support epochs.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-UnitEpoch"><a href="#module-UnitEpoch" class="anchor"></a><code><span><span class="keyword">module</span> <a href="UnitEpoch/index.html">UnitEpoch</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A dummy epochs implementation, if not epoch is needed</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-IntEpoch"><a href="#module-IntEpoch" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IntEpoch/index.html">IntEpoch</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><h2 id="cachemap"><a href="#cachemap" class="anchor"></a>CacheMap</h2><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The output signature of <a href="Make/index.html"><code>Make</code></a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Make/index.html">Make</a></span><span>
+  (<a href="Make/argument-1-Key/index.html">Key</a> : <a href="module-type-Key/index.html">Key</a>)
+  (<a href="Make/argument-2-Value/index.html">Value</a> : <a href="module-type-Value/index.html">Value</a>)
+  (<a href="Make/argument-3-Epoch/index.html">Epoch</a> : <a href="module-type-Epoch/index.html">Epoch</a>) : 
+  <a href="module-type-S/index.html">S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-key">key</a> = <a href="Make/argument-1-Key/index.html#type-t">Key.t</a></span> <span class="keyword">and</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-value">value</a> = <a href="Make/argument-2-Value/index.html#type-t">Value.t</a></span> <span class="keyword">and</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-epoch">epoch</a> = <a href="Make/argument-3-Epoch/index.html#type-t">Epoch.t</a></span></span></code></div><div class="spec-doc"><p>The Key must provide the <a href="module-type-Key/index.html"><code>Key</code></a> interface, where the values must satisfy the <a href="module-type-Value/index.html"><code>Value</code></a> interface.</p></div></div><h2 id="single-cache"><a href="#single-cache" class="anchor"></a>Single Cache</h2><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-SingleS"><a href="#module-type-SingleS" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-SingleS/index.html">SingleS</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The signature of the output of <a href="Single/index.html"><code>Single</code></a></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Single"><a href="#module-Single" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Single/index.html">Single</a></span><span> (<a href="Single/argument-1-Value/index.html">Value</a> : <a href="module-type-Value/index.html">Value</a>) : <a href="module-type-SingleS/index.html">SingleS</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-SingleS/index.html#type-value">value</a> = <a href="Single/argument-1-Value/index.html#type-t">Value.t</a></span></span></code></div><div class="spec-doc"><p>The functor is to make a single cached value. This do not support epochs (Yet)</p></div></div><h2 id="command-line-operations"><a href="#command-line-operations" class="anchor"></a>Command line operations</h2><div class="odoc-spec"><div class="spec module anchored" id="module-Cmd"><a href="#module-Cmd" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cmd/index.html">Cmd</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The cache command line. TODO documentation of the inside</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/module-type-Epoch/index.html b/doc/html/read-dwarf/Utils/Cache/module-type-Epoch/index.html
index 4b92c8be..679f4e6a 100644
--- a/doc/html/read-dwarf/Utils/Cache/module-type-Epoch/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/module-type-Epoch/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Epoch (read-dwarf.Utils.Cache.Epoch)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Epoch</nav><h1>Module type <code>Cache.Epoch</code></h1><p>A cache can be indexed by an Epoch. When reading a cache with an incompatible epoch, then the cache is deleted on load. Use <a href="../UnitEpoch/index.html"><code>UnitEpoch</code></a> to not have this functionality. <a href="../Single/index.html"><code>Single</code></a> caches currently do not support epochs.</p></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../index.html#module-type-Value">Value</a></code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Serialize the value to a file</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the value back from a file. Must match with <a href="index.html#val-to_file"><code>to_file</code></a></p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span class="keyword">val</span> compat : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Tests if epochs are compatible</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Epoch (read-dwarf.Utils.Cache.Epoch)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Epoch</nav><header class="odoc-preamble"><h1>Module type <code><span>Cache.Epoch</span></code></h1><p>A cache can be indexed by an Epoch. When reading a cache with an incompatible epoch, then the cache is deleted on load. Use <a href="../UnitEpoch/index.html"><code>UnitEpoch</code></a> to not have this functionality. <a href="../Single/index.html"><code>Single</code></a> caches currently do not support epochs.</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../module-type-Value/index.html">Value</a></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Serialize the value to a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the value back from a file. Must match with <a href="#val-to_file"><code>to_file</code></a></p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-compat"><a href="#val-compat" class="anchor"></a><code><span><span class="keyword">val</span> compat : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tests if epochs are compatible</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/module-type-Key/index.html b/doc/html/read-dwarf/Utils/Cache/module-type-Key/index.html
index 9f43ae85..dc702027 100644
--- a/doc/html/read-dwarf/Utils/Cache/module-type-Key/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/module-type-Key/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Key (read-dwarf.Utils.Cache.Key)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Key</nav><h1>Module type <code>Cache.Key</code></h1><p>The interface of keys.</p><p>Key are use to index values in the cache, however instead of using the key directly as a file name, the hexadecimal <a href="index.html#val-hash"><code>hash</code></a> of the key is used trough <a href="../index.html#val-int_to_file"><code>int_to_file</code></a>. See <a href="../Make/index.html"><code>Make</code></a> for more details.</p><p>There are two main way of managing keys:</p><ul><li>The hash is injective, in which case there is no need for extra information.</li><li>The hash is not injective, in which case extra information required to disambiguate between different value with the same hash can be used. This information is stored in the file obtained with <a href="../index.html#val-to_keyfile"><code>to_keyfile</code></a> file. See <a href="index.html#val-to_file"><code>to_file</code></a>.</li></ul><p>An implementation can do a mix of both i.e. Putting extra information only for value for which there is hash collision.</p></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.Hashtbl.HashedType</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write the necessary information to retrieve the key in a file. The filename supplied is without the key extension. The implementer must call <a href="../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : int <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build back the key from the hash and a storage file. The filename supplied is without the key extension. The implementer must call <a href="../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it.</p><p>If you start with a <code>key</code> and a <code>file</code>, then doing <code>to_file file key</code> and then <code>of_file (hash key) file</code> must return something <a href="index.html#val-equal"><code>equal</code></a> to key.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Key (read-dwarf.Utils.Cache.Key)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Key</nav><header class="odoc-preamble"><h1>Module type <code><span>Cache.Key</span></code></h1><p>The interface of keys.</p><p>Key are use to index values in the cache, however instead of using the key directly as a file name, the hexadecimal <code>hash</code> of the key is used trough <a href="../index.html#val-int_to_file"><code>int_to_file</code></a>. See <a href="../Make/index.html"><code>Make</code></a> for more details.</p><p>There are two main way of managing keys:</p><ul><li>The hash is injective, in which case there is no need for extra information.</li><li>The hash is not injective, in which case extra information required to disambiguate between different value with the same hash can be used. This information is stored in the file obtained with <a href="../index.html#val-to_keyfile"><code>to_keyfile</code></a> file. See <code>to_file</code>.</li></ul><p>An implementation can do a mix of both i.e. Putting extra information only for value for which there is hash collision.</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.HashedType</span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Write the necessary information to retrieve the key in a file. The filename supplied is without the key extension. The implementer must call <a href="../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>int <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build back the key from the hash and a storage file. The filename supplied is without the key extension. The implementer must call <a href="../index.html#val-to_keyfile"><code>to_keyfile</code></a> on it.</p><p>If you start with a <code>key</code> and a <code>file</code>, then doing <code>to_file file key</code> and then <code>of_file (hash key) file</code> must return something <a href="#val-equal"><code>equal</code></a> to key.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/module-type-S/index.html b/doc/html/read-dwarf/Utils/Cache/module-type-S/index.html
index e63d17b1..f647b0fd 100644
--- a/doc/html/read-dwarf/Utils/Cache/module-type-S/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/module-type-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Utils.Cache.S)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; S</nav><h1>Module type <code>Cache.S</code></h1><p>The output signature of <a href="../Make/index.html"><code>Make</code></a></p></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code></dt><dd><p>The type of keys</p></dd></dl><dl><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code></dt><dd><p>The type of values</p></dd></dl><dl><dt class="spec type" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span class="keyword">type</span> epoch</code></dt><dd><p>The type of the epoch</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type that represent the cache in RAM.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-epoch">epoch</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a new cache management object with a name and an epoch If <code>fake</code> is set, the cache will not touch the disk and behave as a plain Hashtbl.</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dd><p>Get a value from the cache or <code>None</code> if no value is bound to the key</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dd><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add a new binding. Fails if a binding already exists</p></dd></dl><dl><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove a binding (Also delete the representation on disk</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Utils.Cache.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Module type <code><span>Cache.S</span></code></h1><p>The output signature of <a href="../Make/index.html"><code>Make</code></a></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span></code></div><div class="spec-doc"><p>The type of keys</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span></code></div><div class="spec-doc"><p>The type of values</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-epoch"><a href="#type-epoch" class="anchor"></a><code><span><span class="keyword">type</span> epoch</span></code></div><div class="spec-doc"><p>The type of the epoch</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type that represent the cache in RAM.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-epoch">epoch</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a new cache management object with a name and an epoch If <code>fake</code> is set, the cache will not touch the disk and behave as a plain Hashtbl.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div><div class="spec-doc"><p>Get a value from the cache or <code>None</code> if no value is bound to the key</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div><div class="spec-doc"><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add a new binding. Fails if a binding already exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove a binding (Also delete the representation on disk</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/module-type-SingleS/index.html b/doc/html/read-dwarf/Utils/Cache/module-type-SingleS/index.html
index 2512dab0..0904a4c7 100644
--- a/doc/html/read-dwarf/Utils/Cache/module-type-SingleS/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/module-type-SingleS/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SingleS (read-dwarf.Utils.Cache.SingleS)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; SingleS</nav><h1>Module type <code>Cache.SingleS</code></h1><p>The signature of the output of <a href="../Single/index.html"><code>Single</code></a></p></header><dl><dt class="spec type" id="type-value"><a href="#type-value" class="anchor"></a><code><span class="keyword">type</span> value</code></dt><dd><p>The type of the stored value</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type that represent the cache in RAM.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>?&#8288;fake:bool</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Build a new cache management object with a name If <code>fake</code> is set, the cache will not touch the disk and behave as a plain ref.</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><a href="index.html#type-value">value</a> option</span></code></dt><dd><p>Get a value from the cache or <code>None</code> if no value is stored</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a></code></dt><dd><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-value">value</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the value in the cache</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear the value in the cache</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SingleS (read-dwarf.Utils.Cache.SingleS)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; SingleS</nav><header class="odoc-preamble"><h1>Module type <code><span>Cache.SingleS</span></code></h1><p>The signature of the output of <a href="../Single/index.html"><code>Single</code></a></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-value"><a href="#type-value" class="anchor"></a><code><span><span class="keyword">type</span> value</span></code></div><div class="spec-doc"><p>The type of the stored value</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type that represent the cache in RAM.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="optlabel">?fake</span>:bool <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Build a new cache management object with a name If <code>fake</code> is set, the cache will not touch the disk and behave as a plain ref.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> option</span></span></code></div><div class="spec-doc"><p>Get a value from the cache or <code>None</code> if no value is stored</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-value">value</a></span></code></div><div class="spec-doc"><p>Get a value from the cache or throws <code>Not_found</code> if no value is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-value">value</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the value in the cache</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear the value in the cache</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cache/module-type-Value/index.html b/doc/html/read-dwarf/Utils/Cache/module-type-Value/index.html
index a94601e5..e711efcd 100644
--- a/doc/html/read-dwarf/Utils/Cache/module-type-Value/index.html
+++ b/doc/html/read-dwarf/Utils/Cache/module-type-Value/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Utils.Cache.Value)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Value</nav><h1>Module type <code>Cache.Value</code></h1><p>The interface of values: They just need to be able to be serialized to files. This is isn't plain Marshal because some values may want a human readable format.</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt></dl><dl><dt class="spec value" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span class="keyword">val</span> to_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Serialize the value to a file</p></dd></dl><dl><dt class="spec value" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span class="keyword">val</span> of_file : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Get the value back from a file. Must match with <a href="index.html#val-to_file"><code>to_file</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Value (read-dwarf.Utils.Cache.Value)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cache</a> &#x00BB; Value</nav><header class="odoc-preamble"><h1>Module type <code><span>Cache.Value</span></code></h1><p>The interface of values: They just need to be able to be serialized to files. This is isn't plain Marshal because some values may want a human readable format.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_file"><a href="#val-to_file" class="anchor"></a><code><span><span class="keyword">val</span> to_file : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Serialize the value to a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_file"><a href="#val-of_file" class="anchor"></a><code><span><span class="keyword">val</span> of_file : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Get the value back from a file. Must match with <a href="#val-to_file"><code>to_file</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cmd/IOServer/index.html b/doc/html/read-dwarf/Utils/Cmd/IOServer/index.html
index 5f0908e7..26f64385 100644
--- a/doc/html/read-dwarf/Utils/Cmd/IOServer/index.html
+++ b/doc/html/read-dwarf/Utils/Cmd/IOServer/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IOServer (read-dwarf.Utils.Cmd.IOServer)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cmd</a> &#x00BB; IOServer</nav><h1>Module <code>Cmd.IOServer</code></h1><p>This module provide functionality to run command in the background and communicate with it via redirection on it's standard input and output.</p><p>An example of use is in <a href="../../../Z3/index.html"><code>Z3</code></a></p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = </code><code>{</code><table class="record"><tr id="type-t.cmd" class="anchored"><td class="def field"><a href="#type-t.cmd" class="anchor"></a><code>cmd : <a href="../index.html#type-cmd">cmd</a>;</code></td></tr><tr id="type-t.input" class="anchored"><td class="def field"><a href="#type-t.input" class="anchor"></a><code>input : Stdlib.in_channel;</code></td><td class="doc"><p>The output of the command from which answer can be read</p></td></tr><tr id="type-t.output" class="anchored"><td class="def field"><a href="#type-t.output" class="anchor"></a><code>output : Stdlib.out_channel;</code></td><td class="doc"><p>The input of the server on which request can be sent</p></td></tr></table><code>}</code></dt><dd><p>The type of pipe IO server</p></dd></dl><dl><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : <a href="../index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Start the server using the specified command</p></dd></dl><dl><dt class="spec value" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span class="keyword">val</span> stop : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop the server.</p><p>May throw <a href="../index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IOServer (read-dwarf.Utils.Cmd.IOServer)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cmd</a> &#x00BB; IOServer</nav><header class="odoc-preamble"><h1>Module <code><span>Cmd.IOServer</span></code></h1><p>This module provide functionality to run command in the background and communicate with it via redirection on it's standard input and output.</p><p>An example of use is in <a href="../../../Z3/index.html"><code>Z3</code></a></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = </span><span>{</span></code><ol><li id="type-t.cmd" class="def record field anchored"><a href="#type-t.cmd" class="anchor"></a><code><span>cmd : <a href="../index.html#type-cmd">cmd</a>;</span></code></li><li id="type-t.input" class="def record field anchored"><a href="#type-t.input" class="anchor"></a><code><span>input : <span class="xref-unresolved">Stdlib</span>.in_channel;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The output of the command from which answer can be read</p><span class="comment-delim">*)</span></div></li><li id="type-t.output" class="def record field anchored"><a href="#type-t.output" class="anchor"></a><code><span>output : <span class="xref-unresolved">Stdlib</span>.out_channel;</span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The input of the server on which request can be sent</p><span class="comment-delim">*)</span></div></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type of pipe IO server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span><a href="../index.html#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Start the server using the specified command</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span><span class="keyword">val</span> stop : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop the server.</p><p>May throw <a href="../index.html#exception-Crash"><code>Crash</code></a> on error.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cmd/SocketServer/index.html b/doc/html/read-dwarf/Utils/Cmd/SocketServer/index.html
index fd5a1e6a..4887250f 100644
--- a/doc/html/read-dwarf/Utils/Cmd/SocketServer/index.html
+++ b/doc/html/read-dwarf/Utils/Cmd/SocketServer/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SocketServer (read-dwarf.Utils.Cmd.SocketServer)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cmd</a> &#x00BB; SocketServer</nav><h1>Module <code>Cmd.SocketServer</code></h1><p>This module provide functionality for a socket server with which one can communicate on a sockets.</p><p>An example of use is in <a href="../../../Isla/Server/index.html"><code>Isla.Server</code></a></p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The abstract type of a socket server</p></dd></dl><dl><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : <span>name:string</span> <span>&#45;&gt;</span> <span>(string <span>&#45;&gt;</span> <a href="../index.html#type-cmd">cmd</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Start the server with provided name and wait for it to connect to the socket. Then build the <span class="xref-unresolved" title="unresolved reference to &quot;Server.t&quot;"><code>Server</code>.t</span> object. The function argument must take a socket name and give a valid command line to call the server process and make it connect to the socket.</p></dd></dl><dl><dt class="spec value" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span class="keyword">val</span> stop : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop the server and cut the connection, wait for the subprocess to die and then delete the socket</p><p>May throw <a href="../index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl><dl><dt class="spec value" id="val-read_byte"><a href="#val-read_byte" class="anchor"></a><code><span class="keyword">val</span> read_byte : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Read a single byte from the server</p></dd></dl><dl><dt class="spec value" id="val-read_string"><a href="#val-read_string" class="anchor"></a><code><span class="keyword">val</span> read_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Read a string with the following format:</p><p><code>| header : 4 bytes | data : header bytes |</code></p><p>In other words, read a 4 bytes number, then read that number of bytes into a string</p></dd></dl><dl><dt class="spec value" id="val-write_string"><a href="#val-write_string" class="anchor"></a><code><span class="keyword">val</span> write_string : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dd><p>Write a string in the same binary format as <a href="index.html#val-read_string"><code>read_string</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SocketServer (read-dwarf.Utils.Cmd.SocketServer)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Cmd</a> &#x00BB; SocketServer</nav><header class="odoc-preamble"><h1>Module <code><span>Cmd.SocketServer</span></code></h1><p>This module provide functionality for a socket server with which one can communicate on a sockets.</p><p>An example of use is in <a href="../../../Isla/Server/index.html"><code>Isla.Server</code></a></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The abstract type of a socket server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span><span class="label">name</span>:string <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>string <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-cmd">cmd</a>)</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Start the server with provided name and wait for it to connect to the socket. Then build the <code>Server.t</code> object. The function argument must take a socket name and give a valid command line to call the server process and make it connect to the socket.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span><span class="keyword">val</span> stop : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop the server and cut the connection, wait for the subprocess to die and then delete the socket</p><p>May throw <a href="../index.html#exception-Crash"><code>Crash</code></a> on error.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_byte"><a href="#val-read_byte" class="anchor"></a><code><span><span class="keyword">val</span> read_byte : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Read a single byte from the server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_string"><a href="#val-read_string" class="anchor"></a><code><span><span class="keyword">val</span> read_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Read a string with the following format:</p><p><code>| header : 4 bytes | data : header bytes |</code></p><p>In other words, read a 4 bytes number, then read that number of bytes into a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_string"><a href="#val-write_string" class="anchor"></a><code><span><span class="keyword">val</span> write_string : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Write a string in the same binary format as <a href="#val-read_string"><code>read_string</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Cmd/index.html b/doc/html/read-dwarf/Utils/Cmd/index.html
index 54b25bbe..24a0b895 100644
--- a/doc/html/read-dwarf/Utils/Cmd/index.html
+++ b/doc/html/read-dwarf/Utils/Cmd/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cmd (read-dwarf.Utils.Cmd)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Cmd</nav><h1>Module <code>Utils.Cmd</code></h1><nav class="toc"><ul><li><a href="#pipe-calling">Pipe calling</a></li><li><a href="#pipe-server">Pipe server</a></li><li><a href="#socket-server">Socket server</a></li></ul></nav></header><aside><p>This module provides high-level interaction with external processes.</p><p>This provide a functionality similar to <a href="https://erratique.ch/software/bos/doc/Bos.html"><code>Bos</code>)</a>, but this lib is still unstable.</p><p>There are two main mode of communication provided:</p><ul><li>Interaction with pipes: capture the stdin or stdout of the command and use them</li><li>Interaction with socket: Create a socket on which the child program can connect to.</li></ul><p>Programs can be launched in two modes</p><ul><li>Calling: They are called like a function and we wait for them to give a result before contnuing</li><li>Server: The are launch as a background process that stay there and can be called.</li></ul><p>Calling programs can be done with <code>call*</code> function like <a href="index.html#val-call"><code>call</code></a>, <a href="index.html#val-call_read"><code>call_read</code></a>, <a href="index.html#val-call_send"><code>call_send</code></a> and <a href="index.html#val-call_send_read"><code>call_send_read</code></a> and only support pipe interaction</p><p>Server like setups can be done in pipe mode with <a href="IOServer/index.html"><code>IOServer</code></a> and in socket mode with <a href="SocketServer/index.html"><code>SocketServer</code></a>.</p></aside><dl><dt class="spec type" id="type-cmd"><a href="#type-cmd" class="anchor"></a><code><span class="keyword">type</span> cmd</code><code> = <span>string array</span></code></dt><dd><p>The type of a command to be sent. The program to call must be the item 0 of the array</p></dd></dl><dl><dt class="spec exception" id="exception-Crash"><a href="#exception-Crash" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Crash</span> <span class="keyword">of</span> <a href="index.html#type-cmd">cmd</a> * Unix.process_status</code></dt><dd><p>If a program do not return with a 0 exit code, we throw that exception giving the command that failed and the invalid status it returned</p></dd></dl><section><header><h2 id="pipe-calling"><a href="#pipe-calling" class="anchor"></a>Pipe calling</h2></header><dl><dt class="spec value" id="val-call"><a href="#val-call" class="anchor"></a><code><span class="keyword">val</span> call : <a href="index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Call the command without redirecting anything. Wait for completion before returning.</p><p>May throw <a href="index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl><dl><dt class="spec value" id="val-call_send"><a href="#val-call_send" class="anchor"></a><code><span class="keyword">val</span> call_send : <a href="index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> <span>sender:<span>(Stdlib.out_channel <span>&#45;&gt;</span> unit)</span></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Call the command and then call <code>sender</code> to send it some data on it's <code>stdin</code>. Then wait for completion.</p><p>May throw <a href="index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl><dl><dt class="spec value" id="val-call_send_string"><a href="#val-call_send_string" class="anchor"></a><code><span class="keyword">val</span> call_send_string : <a href="index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dd><p>Call the command, send it the string on it's standard input and wait for completion.</p><p>May throw <a href="index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl><dl><dt class="spec value" id="val-call_read"><a href="#val-call_read" class="anchor"></a><code><span class="keyword">val</span> call_read : <a href="index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> <span>reader:<span>(Stdlib.in_channel <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Call the command and then call <code>reader</code> to parse what the command outputs on it's <code>stdout</code>. Then wait for completion and return the parsed value</p><p>May throw <a href="index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl><dl><dt class="spec value" id="val-call_read_string"><a href="#val-call_read_string" class="anchor"></a><code><span class="keyword">val</span> call_read_string : <a href="index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Call the command, wait for completion, and return it's <code>stdout</code> in a string</p></dd></dl><dl><dt class="spec value" id="val-call_send_read"><a href="#val-call_send_read" class="anchor"></a><code><span class="keyword">val</span> call_send_read : <a href="index.html#type-cmd">cmd</a> <span>&#45;&gt;</span> <span>sender:<span>(Stdlib.out_channel <span>&#45;&gt;</span> unit)</span></span> <span>&#45;&gt;</span> <span>reader:<span>(Stdlib.in_channel <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Call the command and then call <code>sender</code> to send the input data on it's <code>stdin</code>. Then call <code>reader</code> to parse an answer from <code>stdout</code> Then wait for completion and return the parsed value</p><p>May throw <a href="index.html#exception-Crash"><code>Crash</code></a> on error.</p></dd></dl></section><section><header><h2 id="pipe-server"><a href="#pipe-server" class="anchor"></a>Pipe server</h2></header><dl><dt class="spec module" id="module-IOServer"><a href="#module-IOServer" class="anchor"></a><code><span class="keyword">module</span> <a href="IOServer/index.html">IOServer</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide functionality to run command in the background and communicate with it via redirection on it's standard input and output.</p></dd></dl></section><section><header><h2 id="socket-server"><a href="#socket-server" class="anchor"></a>Socket server</h2></header><dl><dt class="spec module" id="module-SocketServer"><a href="#module-SocketServer" class="anchor"></a><code><span class="keyword">module</span> <a href="SocketServer/index.html">SocketServer</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This module provide functionality for a socket server with which one can communicate on a sockets.</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Cmd (read-dwarf.Utils.Cmd)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Cmd</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Cmd</span></code></h1><p>This module provides high-level interaction with external processes.</p><p>This provide a functionality similar to <a href="https://erratique.ch/software/bos/doc/Bos.html"><code>Bos</code>)</a>, but this lib is still unstable.</p><p>There are two main mode of communication provided:</p><ul><li>Interaction with pipes: capture the stdin or stdout of the command and use them</li><li>Interaction with socket: Create a socket on which the child program can connect to.</li></ul><p>Programs can be launched in two modes</p><ul><li>Calling: They are called like a function and we wait for them to give a result before contnuing</li><li>Server: The are launch as a background process that stay there and can be called.</li></ul><p>Calling programs can be done with <code>call*</code> function like <a href="#val-call"><code>call</code></a>, <a href="#val-call_read"><code>call_read</code></a>, <a href="#val-call_send"><code>call_send</code></a> and <a href="#val-call_send_read"><code>call_send_read</code></a> and only support pipe interaction</p><p>Server like setups can be done in pipe mode with <a href="IOServer/index.html"><code>IOServer</code></a> and in socket mode with <a href="SocketServer/index.html"><code>SocketServer</code></a>.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#pipe-calling">Pipe calling</a></li><li><a href="#pipe-server">Pipe server</a></li><li><a href="#socket-server">Socket server</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-cmd"><a href="#type-cmd" class="anchor"></a><code><span><span class="keyword">type</span> cmd</span><span> = <span>string array</span></span></code></div><div class="spec-doc"><p>The type of a command to be sent. The program to call must be the item 0 of the array</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Crash"><a href="#exception-Crash" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Crash</span> <span class="keyword">of</span> <a href="#type-cmd">cmd</a> * <span class="xref-unresolved">Unix</span>.process_status</span></code></div><div class="spec-doc"><p>If a program do not return with a 0 exit code, we throw that exception giving the command that failed and the invalid status it returned</p></div></div><h2 id="pipe-calling"><a href="#pipe-calling" class="anchor"></a>Pipe calling</h2><div class="odoc-spec"><div class="spec value anchored" id="val-call"><a href="#val-call" class="anchor"></a><code><span><span class="keyword">val</span> call : <span><a href="#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Call the command without redirecting anything. Wait for completion before returning.</p><p>May throw <a href="#exception-Crash"><code>Crash</code></a> on error.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-call_send"><a href="#val-call_send" class="anchor"></a><code><span><span class="keyword">val</span> call_send : <span><a href="#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">sender</span>:<span>(<span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Call the command and then call <code>sender</code> to send it some data on it's <code>stdin</code>. Then wait for completion.</p><p>May throw <a href="#exception-Crash"><code>Crash</code></a> on error.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-call_send_string"><a href="#val-call_send_string" class="anchor"></a><code><span><span class="keyword">val</span> call_send_string : <span><a href="#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Call the command, send it the string on it's standard input and wait for completion.</p><p>May throw <a href="#exception-Crash"><code>Crash</code></a> on error.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-call_read"><a href="#val-call_read" class="anchor"></a><code><span><span class="keyword">val</span> call_read : <span><a href="#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">reader</span>:<span>(<span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Call the command and then call <code>reader</code> to parse what the command outputs on it's <code>stdout</code>. Then wait for completion and return the parsed value</p><p>May throw <a href="#exception-Crash"><code>Crash</code></a> on error.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-call_read_string"><a href="#val-call_read_string" class="anchor"></a><code><span><span class="keyword">val</span> call_read_string : <span><a href="#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Call the command, wait for completion, and return it's <code>stdout</code> in a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-call_send_read"><a href="#val-call_send_read" class="anchor"></a><code><span><span class="keyword">val</span> call_send_read : 
+  <span><a href="#type-cmd">cmd</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">sender</span>:<span>(<span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">reader</span>:<span>(<span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Call the command and then call <code>sender</code> to send the input data on it's <code>stdin</code>. Then call <code>reader</code> to parse an answer from <code>stdout</code> Then wait for completion and return the parsed value</p><p>May throw <a href="#exception-Crash"><code>Crash</code></a> on error.</p></div></div><h2 id="pipe-server"><a href="#pipe-server" class="anchor"></a>Pipe server</h2><div class="odoc-spec"><div class="spec module anchored" id="module-IOServer"><a href="#module-IOServer" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IOServer/index.html">IOServer</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide functionality to run command in the background and communicate with it via redirection on it's standard input and output.</p></div></div><h2 id="socket-server"><a href="#socket-server" class="anchor"></a>Socket server</h2><div class="odoc-spec"><div class="spec module anchored" id="module-SocketServer"><a href="#module-SocketServer" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SocketServer/index.html">SocketServer</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide functionality for a socket server with which one can communicate on a sockets.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/CmdlinerHelper/index.html b/doc/html/read-dwarf/Utils/CmdlinerHelper/index.html
index 4ddd7981..394c19b5 100644
--- a/doc/html/read-dwarf/Utils/CmdlinerHelper/index.html
+++ b/doc/html/read-dwarf/Utils/CmdlinerHelper/index.html
@@ -1,2 +1,8 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CmdlinerHelper (read-dwarf.Utils.CmdlinerHelper)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; CmdlinerHelper</nav><h1>Module <code>Utils.CmdlinerHelper</code></h1></header><aside><p>This module provide some <code>Cmdliner</code> helper functions.</p></aside><dl><dt class="spec value" id="val-setter"><a href="#val-setter" class="anchor"></a><code><span class="keyword">val</span> setter : <span><span class="type-var">'a</span> Stdlib.ref</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span> <span>&#45;&gt;</span> <span>unit Cmdliner.Term.t</span></code></dt><dd><p>Return a unit <code>Term</code> that evaluates the input term and set the reference to the resulting value.</p><p>Due to the nature of Cmdliner, this may be evaluated multiple times, so setting the reference to anything else is dangerous.</p></dd></dl><dl><dt class="spec value" id="val-add_option"><a href="#val-add_option" class="anchor"></a><code><span class="keyword">val</span> add_option : <span>unit Cmdliner.Term.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span></code></dt><dd><p>Add an unit term that need to be evaluated at the same time at the main term.</p><p>The order of evaluation is unspecified, but the option will be evaluated before the resulting term is returned.</p></dd></dl><dl><dt class="spec value" id="val-add_options"><a href="#val-add_options" class="anchor"></a><code><span class="keyword">val</span> add_options : <span><span>unit Cmdliner.Term.t</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span></code></dt><dd><p>Fold add_option on a list of option</p></dd></dl><dl><dt class="spec value" id="val-func_option"><a href="#val-func_option" class="anchor"></a><code><span class="keyword">val</span> func_option : <span>unit Cmdliner.Term.t</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span></code></dt><dd><p>Replaces Term.const but allow a unit terms (like the one generated by <a href="index.html#val-setter"><code>setter</code></a>) to be evaluated before the function is called</p></dd></dl><dl><dt class="spec value" id="val-func_options"><a href="#val-func_options" class="anchor"></a><code><span class="keyword">val</span> func_options : <span><span>unit Cmdliner.Term.t</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Cmdliner.Term.t</span></code></dt><dd><p>Same as <a href="index.html#val-func_option"><code>func_option</code></a> but with a list of unit terms</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CmdlinerHelper (read-dwarf.Utils.CmdlinerHelper)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; CmdlinerHelper</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.CmdlinerHelper</span></code></h1><p>This module provide some <code>Cmdliner</code> helper functions.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-setter"><a href="#val-setter" class="anchor"></a><code><span><span class="keyword">val</span> setter : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.ref</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div><div class="spec-doc"><p>Return a unit <code>Term</code> that evaluates the input term and set the reference to the resulting value.</p><p>Due to the nature of Cmdliner, this may be evaluated multiple times, so setting the reference to anything else is dangerous.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_option"><a href="#val-add_option" class="anchor"></a><code><span><span class="keyword">val</span> add_option : 
+  <span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div><div class="spec-doc"><p>Add an unit term that need to be evaluated at the same time at the main term.</p><p>The order of evaluation is unspecified, but the option will be evaluated before the resulting term is returned.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_options"><a href="#val-add_options" class="anchor"></a><code><span><span class="keyword">val</span> add_options : 
+  <span><span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div><div class="spec-doc"><p>Fold add_option on a list of option</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-func_option"><a href="#val-func_option" class="anchor"></a><code><span><span class="keyword">val</span> func_option : <span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div><div class="spec-doc"><p>Replaces Term.const but allow a unit terms (like the one generated by <a href="#val-setter"><code>setter</code></a>) to be evaluated before the function is called</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-func_options"><a href="#val-func_options" class="anchor"></a><code><span><span class="keyword">val</span> func_options : <span><span><span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-func_option"><code>func_option</code></a> but with a list of unit terms</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Counter/index.html b/doc/html/read-dwarf/Utils/Counter/index.html
index 28b311e0..36f79d9e 100644
--- a/doc/html/read-dwarf/Utils/Counter/index.html
+++ b/doc/html/read-dwarf/Utils/Counter/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Counter (read-dwarf.Utils.Counter)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Counter</nav><h1>Module <code>Utils.Counter</code></h1></header><aside><p>This module provide a small counter object which is just a int reference on which <a href="index.html#val-get"><code>get</code></a> can be called to get an identifier and increment the reference</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of a counter.</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Make a counter starting from the provided value. This means the first call to <a href="index.html#val-get"><code>get</code></a> on that counter will be the input value:</p><pre><code class="ml">let c = make 42 in
-assert(get c = 42);</code></pre></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the next value of the counter and increment it</p></dd></dl><dl><dt class="spec value" id="val-read"><a href="#val-read" class="anchor"></a><code><span class="keyword">val</span> read : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Get the current value of the counter</p></dd></dl><dl><dt class="spec value" id="val-skip"><a href="#val-skip" class="anchor"></a><code><span class="keyword">val</span> skip : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Skip a value of the counter equivalent to <code>ingore (get ...)</code></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Counter (read-dwarf.Utils.Counter)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Counter</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Counter</span></code></h1><p>This module provide a small counter object which is just a int reference on which <a href="#val-get"><code>get</code></a> can be called to get an identifier and increment the reference</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of a counter.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Make a counter starting from the provided value. This means the first call to <a href="#val-get"><code>get</code></a> on that counter will be the input value:</p><pre class="language-ocaml"><code>let c = make 42 in
+assert(get c = 42);</code></pre></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the next value of the counter and increment it</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read"><a href="#val-read" class="anchor"></a><code><span><span class="keyword">val</span> read : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the current value of the counter</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-skip"><a href="#val-skip" class="anchor"></a><code><span><span class="keyword">val</span> skip : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Skip a value of the counter equivalent to <code>ingore (get ...)</code></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Files/index.html b/doc/html/read-dwarf/Utils/Files/index.html
index d8069710..001fb1bc 100644
--- a/doc/html/read-dwarf/Utils/Files/index.html
+++ b/doc/html/read-dwarf/Utils/Files/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Files (read-dwarf.Utils.Files)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Files</nav><h1>Module <code>Utils.Files</code></h1><nav class="toc"><ul><li><a href="#io-functions">IO functions</a></li><li><a href="#direct-file-io">Direct file IO</a></li><li><a href="#file-management">File management</a></li></ul></nav></header><aside><p>This module provides simplified file management and some channel interaction function.</p><p>The functions <a href="index.html#val-read"><code>read</code></a> and <a href="index.html#val-write"><code>write</code></a> are about dealing with a whole file at once without caring about opening or closing it.</p></aside><dl><dt class="spec type" id="type-reader"><a href="#type-reader" class="anchor"></a><code><span class="keyword">type</span> <span>'a reader</span></code><code> = Stdlib.in_channel <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>The type of a reader that read an object from a channel. Function like <code>input_*</code> in <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Stdlib.html#2_Generalinputfunctions"><code>Stdlib</code></a></p></dd></dl><dl><dt class="spec type" id="type-writer"><a href="#type-writer" class="anchor"></a><code><span class="keyword">type</span> <span>'a writer</span></code><code> = Stdlib.out_channel <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>The type of a writer of 'a. Function named <code>output_*</code> in <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Stdlib.html#2_Generaloutputfunctions"><code>Stdlib</code></a></p></dd></dl><section><header><h2 id="io-functions"><a href="#io-functions" class="anchor"></a>IO functions</h2></header><dl><dt class="spec value" id="val-double_byte"><a href="#val-double_byte" class="anchor"></a><code><span class="keyword">val</span> double_byte : bytes <span>&#45;&gt;</span> bytes</code></dt><dd><p>Double the size of a bytes object (technical function)</p></dd></dl><dl><dt class="spec value" id="val-input_bytes"><a href="#val-input_bytes" class="anchor"></a><code><span class="keyword">val</span> input_bytes : Stdlib.in_channel <span>&#45;&gt;</span> bytes</code></dt><dd><p>Read the whole channel in a bytes</p></dd></dl><dl><dt class="spec value" id="val-input_string"><a href="#val-input_string" class="anchor"></a><code><span class="keyword">val</span> input_string : Stdlib.in_channel <span>&#45;&gt;</span> string</code></dt><dd><p>Read the whole channel in a string</p></dd></dl><dl><dt class="spec value" id="val-input_sexp"><a href="#val-input_sexp" class="anchor"></a><code><span class="keyword">val</span> input_sexp : Stdlib.in_channel <span>&#45;&gt;</span> string</code></dt><dd><p>Reads a S-expression from the input, line by line. When the sexp finishes, there should be nothing else on the line i.e. the last closing parenthesis should be followed by a new line.</p></dd></dl><dl><dt class="spec value" id="val-input_list"><a href="#val-input_list" class="anchor"></a><code><span class="keyword">val</span> input_list : <span><span class="type-var">'a</span> <a href="index.html#type-reader">reader</a></span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dd><p>Try the reader until it fails with <code>End_of_file</code> and then build the list of all the successfully read objects in order.</p></dd></dl><dl><dt class="spec value" id="val-input_array"><a href="#val-input_array" class="anchor"></a><code><span class="keyword">val</span> input_array : <span><span class="type-var">'a</span> <a href="index.html#type-reader">reader</a></span> <span>&#45;&gt;</span> Stdlib.in_channel <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dd><p>Try the reader until it fails with <code>End_of_file</code> and then build the array of all the successfully read objects in order.</p></dd></dl><dl><dt class="spec value" id="val-output_list"><a href="#val-output_list" class="anchor"></a><code><span class="keyword">val</span> output_list : <span><span class="type-var">'a</span> <a href="index.html#type-writer">writer</a></span> <span>&#45;&gt;</span> Stdlib.out_channel <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Output all the element of the list in order with the provided writer</p></dd></dl></section><section><header><h2 id="direct-file-io"><a href="#direct-file-io" class="anchor"></a>Direct file IO</h2></header><dl><dt class="spec value" id="val-read"><a href="#val-read" class="anchor"></a><code><span class="keyword">val</span> read : <span><span class="type-var">'a</span> <a href="index.html#type-reader">reader</a></span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Take a reader and a file and read an object from the file using the reader. Text mode</p></dd></dl><dl><dt class="spec value" id="val-read_bin"><a href="#val-read_bin" class="anchor"></a><code><span class="keyword">val</span> read_bin : <span><span class="type-var">'a</span> <a href="index.html#type-reader">reader</a></span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Take a reader and a file and read an object from the file using the reader. Binary mode</p></dd></dl><dl><dt class="spec value" id="val-write"><a href="#val-write" class="anchor"></a><code><span class="keyword">val</span> write : <span><span class="type-var">'a</span> <a href="index.html#type-writer">writer</a></span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Take a writer a file and object and write the object to the file using writer. Text mode</p></dd></dl><dl><dt class="spec value" id="val-write_bin"><a href="#val-write_bin" class="anchor"></a><code><span class="keyword">val</span> write_bin : <span><span class="type-var">'a</span> <a href="index.html#type-writer">writer</a></span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Take a writer fs a file and object and write the object to the file using writer. Binary mode</p></dd></dl><dl><dt class="spec value" id="val-read_string"><a href="#val-read_string" class="anchor"></a><code><span class="keyword">val</span> read_string : string <span>&#45;&gt;</span> string</code></dt><dd><p>Return the content of specified file as a string</p></dd></dl><dl><dt class="spec value" id="val-write_string"><a href="#val-write_string" class="anchor"></a><code><span class="keyword">val</span> write_string : string <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dd><p><code>write_string file cont</code> write <code>cont</code> in <code>file</code> which is overwritten if it exists</p></dd></dl></section><section><header><h2 id="file-management"><a href="#file-management" class="anchor"></a>File management</h2></header><dl><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove a file</p></dd></dl><dl><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : string <span>&#45;&gt;</span> bool</code></dt><dd><p>Test if a files exists</p></dd></dl><dl><dt class="spec value" id="val-remove_at_exit"><a href="#val-remove_at_exit" class="anchor"></a><code><span class="keyword">val</span> remove_at_exit : string <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove a file at program exit</p></dd></dl><dl><dt class="spec value" id="val-add_to_relative"><a href="#val-add_to_relative" class="anchor"></a><code><span class="keyword">val</span> add_to_relative : <span>newp:string</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string</code></dt><dd><p>Add <code>newp</code> in front of a relative path. If the path is not relative, then it is unchanged</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Files (read-dwarf.Utils.Files)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Files</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Files</span></code></h1><p>This module provides simplified file management and some channel interaction function.</p><p>The functions <a href="#val-read"><code>read</code></a> and <a href="#val-write"><code>write</code></a> are about dealing with a whole file at once without caring about opening or closing it.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#io-functions">IO functions</a></li><li><a href="#direct-file-io">Direct file IO</a></li><li><a href="#file-management">File management</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-reader"><a href="#type-reader" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a reader</span></span><span> = <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>The type of a reader that read an object from a channel. Function like <code>input_*</code> in <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Stdlib.html#2_Generalinputfunctions"><code>Stdlib</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-writer"><a href="#type-writer" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a writer</span></span><span> = <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>The type of a writer of 'a. Function named <code>output_*</code> in <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Stdlib.html#2_Generaloutputfunctions"><code>Stdlib</code></a></p></div></div><h2 id="io-functions"><a href="#io-functions" class="anchor"></a>IO functions</h2><div class="odoc-spec"><div class="spec value anchored" id="val-double_byte"><a href="#val-double_byte" class="anchor"></a><code><span><span class="keyword">val</span> double_byte : <span>bytes <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div><div class="spec-doc"><p>Double the size of a bytes object (technical function)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_bytes"><a href="#val-input_bytes" class="anchor"></a><code><span><span class="keyword">val</span> input_bytes : <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div><div class="spec-doc"><p>Read the whole channel in a bytes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_string"><a href="#val-input_string" class="anchor"></a><code><span><span class="keyword">val</span> input_string : <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Read the whole channel in a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_sexp"><a href="#val-input_sexp" class="anchor"></a><code><span><span class="keyword">val</span> input_sexp : <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Reads a S-expression from the input, line by line. When the sexp finishes, there should be nothing else on the line i.e. the last closing parenthesis should be followed by a new line.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_list"><a href="#val-input_list" class="anchor"></a><code><span><span class="keyword">val</span> input_list : <span><span><span class="type-var">'a</span> <a href="#type-reader">reader</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Try the reader until it fails with <code>End_of_file</code> and then build the list of all the successfully read objects in order.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-input_array"><a href="#val-input_array" class="anchor"></a><code><span><span class="keyword">val</span> input_array : <span><span><span class="type-var">'a</span> <a href="#type-reader">reader</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.in_channel <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div><div class="spec-doc"><p>Try the reader until it fails with <code>End_of_file</code> and then build the array of all the successfully read objects in order.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-output_list"><a href="#val-output_list" class="anchor"></a><code><span><span class="keyword">val</span> output_list : <span><span><span class="type-var">'a</span> <a href="#type-writer">writer</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Output all the element of the list in order with the provided writer</p></div></div><h2 id="direct-file-io"><a href="#direct-file-io" class="anchor"></a>Direct file IO</h2><div class="odoc-spec"><div class="spec value anchored" id="val-read"><a href="#val-read" class="anchor"></a><code><span><span class="keyword">val</span> read : <span><span><span class="type-var">'a</span> <a href="#type-reader">reader</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Take a reader and a file and read an object from the file using the reader. Text mode</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_bin"><a href="#val-read_bin" class="anchor"></a><code><span><span class="keyword">val</span> read_bin : <span><span><span class="type-var">'a</span> <a href="#type-reader">reader</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Take a reader and a file and read an object from the file using the reader. Binary mode</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write"><a href="#val-write" class="anchor"></a><code><span><span class="keyword">val</span> write : <span><span><span class="type-var">'a</span> <a href="#type-writer">writer</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Take a writer a file and object and write the object to the file using writer. Text mode</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_bin"><a href="#val-write_bin" class="anchor"></a><code><span><span class="keyword">val</span> write_bin : <span><span><span class="type-var">'a</span> <a href="#type-writer">writer</a></span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Take a writer fs a file and object and write the object to the file using writer. Binary mode</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_string"><a href="#val-read_string" class="anchor"></a><code><span><span class="keyword">val</span> read_string : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Return the content of specified file as a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-write_string"><a href="#val-write_string" class="anchor"></a><code><span><span class="keyword">val</span> write_string : <span>string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p><code>write_string file cont</code> write <code>cont</code> in <code>file</code> which is overwritten if it exists</p></div></div><h2 id="file-management"><a href="#file-management" class="anchor"></a>File management</h2><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove a file</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test if a files exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_at_exit"><a href="#val-remove_at_exit" class="anchor"></a><code><span><span class="keyword">val</span> remove_at_exit : <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove a file at program exit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_to_relative"><a href="#val-add_to_relative" class="anchor"></a><code><span><span class="keyword">val</span> add_to_relative : <span><span class="label">newp</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Add <code>newp</code> in front of a relative path. If the path is not relative, then it is unchanged</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/FullVec/index.html b/doc/html/read-dwarf/Utils/FullVec/index.html
index ab6aeb9c..29fd72ad 100644
--- a/doc/html/read-dwarf/Utils/FullVec/index.html
+++ b/doc/html/read-dwarf/Utils/FullVec/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>FullVec (read-dwarf.Utils.FullVec)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; FullVec</nav><h1>Module <code>Utils.FullVec</code></h1></header><aside><p>A full vector is a vector in which all non-negative integer are bound.</p><p>This consist in a normal vector and a function and all the bindings of value after the vector end are the result of the function call on that integer.</p><p>It is guaranted that the function will be called lazily on integer when required in stricly increasing order (and thus never twice on the same integer). However an integer may be skipped (When manually set). That means the function can have side effect if necessary. However if the structure is copied (<a href="index.html#val-map"><code>map</code></a> or <a href="index.html#val-copy"><code>copy</code></a>), The generator may be called multiple time on some integer in the different copies.</p><p>Both set and get may generate calls to the generator if required.</p><p>Any attempt to use a negative integer will raise <code>Invalid_argument</code>.</p><p>A negative integer will never be passed to the generator.</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code></dt></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Create a full vector from a generator</p></dd></dl><dl><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Make a copy that can be mutated separately</p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the binding of that integer</p></dd></dl><dl><dt class="spec value" id="val-set_after"><a href="#val-set_after" class="anchor"></a><code><span class="keyword">val</span> set_after : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the binding of all integer after this value by supplying a new generator. The former generator is discarded. The bindings before the value keep their value (if there were not generated, they will be before discarding the old generator</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Get the binding of that integer</p></dd></dl><dl><dt class="spec value" id="val-get_vec"><a href="#val-get_vec" class="anchor"></a><code><span class="keyword">val</span> get_vec : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../Vec/index.html#type-t">Vec.t</a></span></code></dt><dd><p>Get the underlying vector</p></dd></dl><dl><dt class="spec value" id="val-get_vec_until"><a href="#val-get_vec_until" class="anchor"></a><code><span class="keyword">val</span> get_vec_until : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../Vec/index.html#type-t">Vec.t</a></span></code></dt><dd><p>Get a vector containing at least the elements until the specified value excluded</p></dd></dl><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Map the function over the fullvec. Postcompose the map on the generator</p></dd></dl><dl><dt class="spec value" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span class="keyword">val</span> map_mut : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map the function over the fullvector by mutation. Postcompose the map on the generator.contents Warning, a lot of <a href="index.html#val-map_mut"><code>map_mut</code></a> may make the generator big and slow. Maybe try to use <a href="index.html#val-set_after"><code>set_after</code></a> to reset it when required.</p></dd></dl><dl><dt class="spec value" id="val-map_mut_until"><a href="#val-map_mut_until" class="anchor"></a><code><span class="keyword">val</span> map_mut_until : <span>limit:int</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map the function over the fullvector until the limit. The rest is unchanged</p></dd></dl><dl><dt class="spec value" id="val-iter_until"><a href="#val-iter_until" class="anchor"></a><code><span class="keyword">val</span> iter_until : <span>limit:int</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterate until the specified value (excluded). (The FullVec is infinite so you can't iter on all of it)</p></dd></dl><dl><dt class="spec value" id="val-iteri_until"><a href="#val-iteri_until" class="anchor"></a><code><span class="keyword">val</span> iteri_until : <span>limit:int</span> <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-iter_until"><code>iter_until</code></a> but with the index</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Only prints the non-default values</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>FullVec (read-dwarf.Utils.FullVec)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; FullVec</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.FullVec</span></code></h1><p>A full vector is a vector in which all non-negative integer are bound.</p><p>This consist in a normal vector and a function and all the bindings of value after the vector end are the result of the function call on that integer.</p><p>It is guaranted that the function will be called lazily on integer when required in stricly increasing order (and thus never twice on the same integer). However an integer may be skipped (When manually set). That means the function can have side effect if necessary. However if the structure is copied (<a href="#val-map"><code>map</code></a> or <a href="#val-copy"><code>copy</code></a>), The generator may be called multiple time on some integer in the different copies.</p><p>Both set and get may generate calls to the generator if required.</p><p>Any attempt to use a negative integer will raise <code>Invalid_argument</code>.</p><p>A negative integer will never be passed to the generator.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Create a full vector from a generator</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Make a copy that can be mutated separately</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the binding of that integer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_after"><a href="#val-set_after" class="anchor"></a><code><span><span class="keyword">val</span> set_after : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the binding of all integer after this value by supplying a new generator. The former generator is discarded. The bindings before the value keep their value (if there were not generated, they will be before discarding the old generator</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Get the binding of that integer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_vec"><a href="#val-get_vec" class="anchor"></a><code><span><span class="keyword">val</span> get_vec : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Vec/index.html#type-t">Vec.t</a></span></span></code></div><div class="spec-doc"><p>Get the underlying vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_vec_until"><a href="#val-get_vec_until" class="anchor"></a><code><span><span class="keyword">val</span> get_vec_until : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Vec/index.html#type-t">Vec.t</a></span></span></code></div><div class="spec-doc"><p>Get a vector containing at least the elements until the specified value excluded</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Map the function over the fullvec. Postcompose the map on the generator</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-map"><code>map</code></a> but with the index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span><span class="keyword">val</span> map_mut : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map the function over the fullvector by mutation. Postcompose the map on the generator.contents Warning, a lot of <a href="#val-map_mut"><code>map_mut</code></a> may make the generator big and slow. Maybe try to use <a href="#val-set_after"><code>set_after</code></a> to reset it when required.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut_until"><a href="#val-map_mut_until" class="anchor"></a><code><span><span class="keyword">val</span> map_mut_until : <span><span class="label">limit</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map the function over the fullvector until the limit. The rest is unchanged</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_until"><a href="#val-iter_until" class="anchor"></a><code><span><span class="keyword">val</span> iter_until : <span><span class="label">limit</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterate until the specified value (excluded). (The FullVec is infinite so you can't iter on all of it)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri_until"><a href="#val-iteri_until" class="anchor"></a><code><span><span class="keyword">val</span> iteri_until : <span><span class="label">limit</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-iter_until"><code>iter_until</code></a> but with the index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Only prints the non-default values</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Fun/index.html b/doc/html/read-dwarf/Utils/Fun/index.html
index 85731d97..cc57d738 100644
--- a/doc/html/read-dwarf/Utils/Fun/index.html
+++ b/doc/html/read-dwarf/Utils/Fun/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Fun (read-dwarf.Utils.Fun)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Fun</nav><h1>Module <code>Utils.Fun</code></h1></header><aside><p>More functional combinator. This module extends the base OCaml API of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html"><code>Fun</code></a>.</p></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.Fun</code></span></summary><dl><dt class="spec external" id="val-id"><a href="#val-id" class="anchor"></a><code><span class="keyword">val</span> id : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec value" id="val-const"><a href="#val-const" class="anchor"></a><code><span class="keyword">val</span> const : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-flip"><a href="#val-flip" class="anchor"></a><code><span class="keyword">val</span> flip : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'c</span></code></dt><dt class="spec value" id="val-negate"><a href="#val-negate" class="anchor"></a><code><span class="keyword">val</span> negate : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-protect"><a href="#val-protect" class="anchor"></a><code><span class="keyword">val</span> protect : <span>finally:<span>(unit <span>&#45;&gt;</span> unit)</span></span> <span>&#45;&gt;</span> <span>(unit <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt></dl><dl><dt class="spec exception" id="exception-Finally_raised"><a href="#exception-Finally_raised" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Finally_raised</span> <span class="keyword">of</span> exn</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-($)"><a href="#val-($)" class="anchor"></a><code><span class="keyword">val</span> ($) : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>An other application operator. <code>g @@ f @@ 4</code> replaces <code>g (f 4)</code> but <code>h $ g 4 $ f 5</code> replaces <code>h (g 4) (f 5)</code></p><p><code>@@</code> has higher precedence so <code>h $ g @@ f 4 $ t @@ p 5 = h (g (f 4)) (t (p 5))</code> but in practice, I would advise not to mix them.</p></dd></dl><dl><dt class="spec value" id="val-(%&gt;)"><a href="#val-(%&gt;)" class="anchor"></a><code><span class="keyword">val</span> (%&gt;) : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'c</span></code></dt><dd><p>Abstraction of piping above a parameter useful to refactor things like <code>List.map f |&gt; List.map g</code> into <code>List.map (f %&gt; g)</code>.</p><p>The trivial definition is <code>x |&gt; (f %&gt; g) = x |&gt; f |&gt; g</code></p></dd></dl><dl><dt class="spec value" id="val-tee"><a href="#val-tee" class="anchor"></a><code><span class="keyword">val</span> tee : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>When you want to run some imperative code on a value before continuing the pipeline</p></dd></dl><dl><dt class="spec value" id="val-curry"><a href="#val-curry" class="anchor"></a><code><span class="keyword">val</span> curry : <span>(<span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span></code></dt><dd><p><code>curry f a b = f (a, b)</code></p></dd></dl><dl><dt class="spec value" id="val-uncurry"><a href="#val-uncurry" class="anchor"></a><code><span class="keyword">val</span> uncurry : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'c</span></code></dt><dd><p><code>uncurry f (a, b) = f a b</code></p></dd></dl><dl><dt class="spec value" id="val-ctrue"><a href="#val-ctrue" class="anchor"></a><code><span class="keyword">val</span> ctrue : <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Shorthand for <code>const true</code></p></dd></dl><dl><dt class="spec value" id="val-cfalse"><a href="#val-cfalse" class="anchor"></a><code><span class="keyword">val</span> cfalse : <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Shorthand for <code>const false</code></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Fun (read-dwarf.Utils.Fun)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Fun</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Fun</span></code></h1><p>More functional combinator. This module extends the base OCaml API of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html"><code>Fun</code></a>.</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.Fun <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value external anchored" id="val-id"><a href="#val-id" class="anchor"></a><code><span><span class="keyword">val</span> id : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-const"><a href="#val-const" class="anchor"></a><code><span><span class="keyword">val</span> const : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flip"><a href="#val-flip" class="anchor"></a><code><span><span class="keyword">val</span> flip : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-negate"><a href="#val-negate" class="anchor"></a><code><span><span class="keyword">val</span> negate : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-protect"><a href="#val-protect" class="anchor"></a><code><span><span class="keyword">val</span> protect : <span><span class="label">finally</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Finally_raised"><a href="#exception-Finally_raised" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Finally_raised</span> <span class="keyword">of</span> exn</span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-($)"><a href="#val-($)" class="anchor"></a><code><span><span class="keyword">val</span> ($) : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>An other application operator. <code>g @@ f @@ 4</code> replaces <code>g (f 4)</code> but <code>h $ g 4 $ f 5</code> replaces <code>h (g 4) (f 5)</code></p><p><code>@@</code> has higher precedence so <code>h $ g @@ f 4 $ t @@ p 5 = h (g (f 4)) (t (p 5))</code> but in practice, I would advise not to mix them.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(%&gt;)"><a href="#val-(%&gt;)" class="anchor"></a><code><span><span class="keyword">val</span> (%&gt;) : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span></span></code></div><div class="spec-doc"><p>Abstraction of piping above a parameter useful to refactor things like <code>List.map f |&gt; List.map g</code> into <code>List.map (f %&gt; g)</code>.</p><p>The trivial definition is <code>x |&gt; (f %&gt; g) = x |&gt; f |&gt; g</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tee"><a href="#val-tee" class="anchor"></a><code><span><span class="keyword">val</span> tee : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>When you want to run some imperative code on a value before continuing the pipeline</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-curry"><a href="#val-curry" class="anchor"></a><code><span><span class="keyword">val</span> curry : <span><span>(<span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span></span></code></div><div class="spec-doc"><p><code>curry f a b = f (a, b)</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uncurry"><a href="#val-uncurry" class="anchor"></a><code><span><span class="keyword">val</span> uncurry : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span></span></code></div><div class="spec-doc"><p><code>uncurry f (a, b) = f a b</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ctrue"><a href="#val-ctrue" class="anchor"></a><code><span><span class="keyword">val</span> ctrue : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Shorthand for <code>const true</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cfalse"><a href="#val-cfalse" class="anchor"></a><code><span><span class="keyword">val</span> cfalse : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Shorthand for <code>const false</code></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/HashVector/index.html b/doc/html/read-dwarf/Utils/HashVector/index.html
index 3f39059f..f91a7063 100644
--- a/doc/html/read-dwarf/Utils/HashVector/index.html
+++ b/doc/html/read-dwarf/Utils/HashVector/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>HashVector (read-dwarf.Utils.HashVector)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; HashVector</nav><h1>Module <code>Utils.HashVector</code></h1></header><aside><p>An hash vector allow a vector to behave as hash map indexed by small integers. It is hash map with the identity hash function.</p><p>If all goes well it has the same API as <code>(int, 'a) Hashtbl.t</code> for positive integers. Any attempt to use a negative integer will raise <code>Invalid_argument</code>.</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code></dt><dd><p>The type of the hash vector</p></dd></dl><dl><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if an element is set</p></dd></dl><dl><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Copy the HashVector</p></dd></dl><dl><dt class="spec exception" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Exists</span></code></dt></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a value. Create a new binding if necessary</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear a binding, do nothing is the value is not bound.</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Create a new binding. Throws <a href="index.html#exception-Exists"><code>Exists</code></a> if a binding already exists</p></dd></dl><dl><dt class="spec value" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span class="keyword">val</span> get_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Return <code>Some v</code> if v is bound to the integer in the hash vector. Return <code>None</code> if nothing is bound</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Return the value bound to the integer. Throw <code>Not_found</code> if the integer is not bound</p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : unit <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Create an empty hashVector.t</p></dd></dl><dl><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> list</span></code></dt><dd><p>Returns a list of bindings in the hash vector</p></dd></dl><dl><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../index.html#module-Seq">Utils.Seq</a>.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Fill the hashVector from a sequence</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty print a hashVector</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>HashVector (read-dwarf.Utils.HashVector)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; HashVector</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.HashVector</span></code></h1><p>An hash vector allow a vector to behave as hash map indexed by small integers. It is hash map with the identity hash function.</p><p>If all goes well it has the same API as <code>(int, 'a) Hashtbl.t</code> for positive integers. Any attempt to use a negative integer will raise <code>Invalid_argument</code>.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span></code></div><div class="spec-doc"><p>The type of the hash vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if an element is set</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Copy the HashVector</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Exists</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a value. Create a new binding if necessary</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear a binding, do nothing is the value is not bound.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Create a new binding. Throws <a href="#exception-Exists"><code>Exists</code></a> if a binding already exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_opt"><a href="#val-get_opt" class="anchor"></a><code><span><span class="keyword">val</span> get_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Return <code>Some v</code> if v is bound to the integer in the hash vector. Return <code>None</code> if nothing is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Return the value bound to the integer. Throw <code>Not_found</code> if the integer is not bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Create an empty hashVector.t</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> list</span></span></code></div><div class="spec-doc"><p>Returns a list of bindings in the hash vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span>(int * <span class="type-var">'a</span>)</span> <a href="../Seq/index.html#type-t">Seq.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Fill the hashVector from a sequence</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty print a hashVector</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/IdMap/index.html b/doc/html/read-dwarf/Utils/IdMap/index.html
index 7346db5b..db581062 100644
--- a/doc/html/read-dwarf/Utils/IdMap/index.html
+++ b/doc/html/read-dwarf/Utils/IdMap/index.html
@@ -1,2 +1,7 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IdMap (read-dwarf.Utils.IdMap)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; IdMap</nav><h1>Module <code>Utils.IdMap</code></h1><nav class="toc"><ul><li><a href="#creation-and-adding">Creation and adding</a></li><li><a href="#keys">Keys</a></li><li><a href="#accessors">Accessors</a></li><li><a href="#functional-accessors">Functional accessors</a></li><li><a href="#pretty-print">Pretty print</a></li></ul></nav></header><aside><p>An IdMap is a map that associate an id to each key (and thus to each value).</p><p>The value can be indexed with the key or with the id.</p><p>The key can be retrieved from the id and vice versa.</p><p>Values can be retreived from both keys and value (</p><p>The id is an <code>int</code></p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'b) t</span></code></dt><dd><p>The type of a idmap</p><p><code>'a</code> is type of keys that index the structure</p><p><code>'b</code> is the type of value that are indexed.</p></dd></dl><dl><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dd><p>Gives the number of bindings in the idmap</p></dd></dl><dl><dt class="spec exception" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Exists</span></code></dt><dd><p>Thrown when adding an existing value</p></dd></dl><section><header><h2 id="creation-and-adding"><a href="#creation-and-adding" class="anchor"></a>Creation and adding</h2></header><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : unit <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Create a new idmap from scratch</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> int</code></dt><dd><p>Add a binding, and throw <a href="index.html#exception-Exists"><code>Exists</code></a> if the binding already exists</p></dd></dl><dl><dt class="spec value" id="val-adds"><a href="#val-adds" class="anchor"></a><code><span class="keyword">val</span> adds : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Silent version of <a href="index.html#val-add"><code>add</code></a> that ignore the result</p></dd></dl></section><section><header><h2 id="keys"><a href="#keys" class="anchor"></a>Keys</h2></header><dl><dt class="spec value" id="val-to_ident"><a href="#val-to_ident" class="anchor"></a><code><span class="keyword">val</span> to_ident : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int</code></dt><dd><p>Convert a key in an identifier. Throws if the key is not bound</p></dd></dl><dl><dt class="spec value" id="val-to_ident_opt"><a href="#val-to_ident_opt" class="anchor"></a><code><span class="keyword">val</span> to_ident_opt : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span>int option</span></code></dt><dd><p>Convert a key in an identifier. None if the key is not bound</p></dd></dl><dl><dt class="spec value" id="val-of_ident"><a href="#val-of_ident" class="anchor"></a><code><span class="keyword">val</span> of_ident : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Convert an identifier to its corresponding key. Throws if the id is not bound</p></dd></dl><dl><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if a key is bound</p></dd></dl><dl><dt class="spec value" id="val-mem_id"><a href="#val-mem_id" class="anchor"></a><code><span class="keyword">val</span> mem_id : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if an id is bound</p></dd></dl></section><section><header><h2 id="accessors"><a href="#accessors" class="anchor"></a>Accessors</h2></header><dl><dt class="spec value" id="val-getk"><a href="#val-getk" class="anchor"></a><code><span class="keyword">val</span> getk : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>Get a value by key. Raise <code>Not_found</code> if the key is not bound.</p></dd></dl><dl><dt class="spec value" id="val-getk_opt"><a href="#val-getk_opt" class="anchor"></a><code><span class="keyword">val</span> getk_opt : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dd><p>Get a value by key. None if the key is not bound.</p></dd></dl><dl><dt class="spec value" id="val-geti"><a href="#val-geti" class="anchor"></a><code><span class="keyword">val</span> geti : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>Get a value by id. Raise <code>Invalid_argument</code> if the index is not bound.</p></dd></dl><dl><dt class="spec value" id="val-unsafe_geti"><a href="#val-unsafe_geti" class="anchor"></a><code><span class="keyword">val</span> unsafe_geti : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>Get a value by id, unsafe.</p></dd></dl><dl><dt class="spec value" id="val-setk"><a href="#val-setk" class="anchor"></a><code><span class="keyword">val</span> setk : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a value by key. Raise <code>Not_found</code> if the key is not bound.</p></dd></dl><dl><dt class="spec value" id="val-seti"><a href="#val-seti" class="anchor"></a><code><span class="keyword">val</span> seti : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a value by id. Raise <code>Invalid_argument</code> if the index is not bound.</p></dd></dl><dl><dt class="spec value" id="val-unsafe_seti"><a href="#val-unsafe_seti" class="anchor"></a><code><span class="keyword">val</span> unsafe_seti : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a value by id, unsafe.</p></dd></dl><dl><dt class="spec value" id="val-fill_all"><a href="#val-fill_all" class="anchor"></a><code><span class="keyword">val</span> fill_all : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Bind the value to all the keys with the specified value.</p></dd></dl></section><section><header><h2 id="functional-accessors"><a href="#functional-accessors" class="anchor"></a>Functional accessors</h2></header><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Call the function on all the bindings of the idmap</p></dd></dl><dl><dt class="spec value" id="val-map_to_list"><a href="#val-map_to_list" class="anchor"></a><code><span class="keyword">val</span> map_to_list : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> list</span></code></dt><dd><p>Call the function on all the bindings of the idmap and return the list of results</p></dd></dl></section><section><header><h2 id="pretty-print"><a href="#pretty-print" class="anchor"></a>Pretty print</h2></header><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span>?&#8288;name:string</span> <span>&#45;&gt;</span> <span>keys:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document)</span></span> <span>&#45;&gt;</span> <span>vals:<span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IdMap (read-dwarf.Utils.IdMap)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; IdMap</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.IdMap</span></code></h1><p>An IdMap is a map that associate an id to each key (and thus to each value).</p><p>The value can be indexed with the key or with the id.</p><p>The key can be retrieved from the id and vice versa.</p><p>Values can be retreived from both keys and value (</p><p>The id is an <code>int</code></p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#creation-and-adding">Creation and adding</a></li><li><a href="#keys">Keys</a></li><li><a href="#accessors">Accessors</a></li><li><a href="#functional-accessors">Functional accessors</a></li><li><a href="#pretty-print">Pretty print</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'b) t</span></span></code></div><div class="spec-doc"><p>The type of a idmap</p><p><code>'a</code> is type of keys that index the structure</p><p><code>'b</code> is the type of value that are indexed.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Gives the number of bindings in the idmap</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Exists</span></span></code></div><div class="spec-doc"><p>Thrown when adding an existing value</p></div></div><h2 id="creation-and-adding"><a href="#creation-and-adding" class="anchor"></a>Creation and adding</h2><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Create a new idmap from scratch</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Add a binding, and throw <a href="#exception-Exists"><code>Exists</code></a> if the binding already exists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-adds"><a href="#val-adds" class="anchor"></a><code><span><span class="keyword">val</span> adds : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Silent version of <a href="#val-add"><code>add</code></a> that ignore the result</p></div></div><h2 id="keys"><a href="#keys" class="anchor"></a>Keys</h2><div class="odoc-spec"><div class="spec value anchored" id="val-to_ident"><a href="#val-to_ident" class="anchor"></a><code><span><span class="keyword">val</span> to_ident : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Convert a key in an identifier. Throws if the key is not bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_ident_opt"><a href="#val-to_ident_opt" class="anchor"></a><code><span><span class="keyword">val</span> to_ident_opt : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div><div class="spec-doc"><p>Convert a key in an identifier. None if the key is not bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_ident"><a href="#val-of_ident" class="anchor"></a><code><span><span class="keyword">val</span> of_ident : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Convert an identifier to its corresponding key. Throws if the id is not bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if a key is bound</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_id"><a href="#val-mem_id" class="anchor"></a><code><span><span class="keyword">val</span> mem_id : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if an id is bound</p></div></div><h2 id="accessors"><a href="#accessors" class="anchor"></a>Accessors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-getk"><a href="#val-getk" class="anchor"></a><code><span><span class="keyword">val</span> getk : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Get a value by key. Raise <code>Not_found</code> if the key is not bound.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-getk_opt"><a href="#val-getk_opt" class="anchor"></a><code><span><span class="keyword">val</span> getk_opt : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p>Get a value by key. None if the key is not bound.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-geti"><a href="#val-geti" class="anchor"></a><code><span><span class="keyword">val</span> geti : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Get a value by id. Raise <code>Invalid_argument</code> if the index is not bound.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_geti"><a href="#val-unsafe_geti" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_geti : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Get a value by id, unsafe.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-setk"><a href="#val-setk" class="anchor"></a><code><span><span class="keyword">val</span> setk : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a value by key. Raise <code>Not_found</code> if the key is not bound.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-seti"><a href="#val-seti" class="anchor"></a><code><span><span class="keyword">val</span> seti : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a value by id. Raise <code>Invalid_argument</code> if the index is not bound.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_seti"><a href="#val-unsafe_seti" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_seti : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a value by id, unsafe.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fill_all"><a href="#val-fill_all" class="anchor"></a><code><span><span class="keyword">val</span> fill_all : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Bind the value to all the keys with the specified value.</p></div></div><h2 id="functional-accessors"><a href="#functional-accessors" class="anchor"></a>Functional accessors</h2><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Call the function on all the bindings of the idmap</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_to_list"><a href="#val-map_to_list" class="anchor"></a><code><span><span class="keyword">val</span> map_to_list : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> list</span></span></code></div><div class="spec-doc"><p>Call the function on all the bindings of the idmap and return the list of results</p></div></div><h2 id="pretty-print"><a href="#pretty-print" class="anchor"></a>Pretty print</h2><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : 
+  <span><span class="optlabel">?name</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">keys</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">vals</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/IntBits/index.html b/doc/html/read-dwarf/Utils/IntBits/index.html
index c2b95d27..e0de5068 100644
--- a/doc/html/read-dwarf/Utils/IntBits/index.html
+++ b/doc/html/read-dwarf/Utils/IntBits/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IntBits (read-dwarf.Utils.IntBits)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; IntBits</nav><h1>Module <code>Utils.IntBits</code></h1></header><aside><p>Manipulate an int as bitfield of size 31 or 63.</p><p>I'm tired of having to think about bit shifts and bitwise operations when I do that stuff</p><p>Little endian indexing (0 is the least significant bit)</p><p>Ranges are specified with and index and a length. The index must be in <code>[0,length)</code> and the length must be in <code>(0,length]</code>. Those conditions will be named &quot;valid range&quot;. Any range specified in that way can go after the end. When reading, it will behave as if it was zeroes, and on writes, all bits after the end are discarded.</p><p>All unsafe function implicitely assume that all indexes and ranges are valid. All safe functions throw if those conditions are not met.</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = int</code></dt><dd><p>The type of a int as a bitfield. This is just to make signatures clearer</p></dd></dl><dl><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : int</code></dt><dd><p>The length of an integer in bits (<code>Sys.int_size</code>)</p></dd></dl><dl><dt class="spec value" id="val-back"><a href="#val-back" class="anchor"></a><code><span class="keyword">val</span> back : int</code></dt><dd><p>The last index in an integer</p></dd></dl><dl><dt class="spec value" id="val-check_index"><a href="#val-check_index" class="anchor"></a><code><span class="keyword">val</span> check_index : int <span>&#45;&gt;</span> unit</code></dt><dd><p>Check that the index is valid to index an integer.</p><p>Throw <code>Invalid_argument</code> if the index is not valid</p></dd></dl><dl><dt class="spec value" id="val-check_range"><a href="#val-check_range" class="anchor"></a><code><span class="keyword">val</span> check_range : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Check that the range is valid to index an integer. See module documentation (<a href="index.html"><code>IntBits</code></a>) for the definition of a valid range.</p><p>Throw <code>Invalid_argument</code> if the range is not valid.</p></dd></dl><dl><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : bool <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Initialize an int with all zeros or all ones depending on the boolean</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Get a bit at a specific index. See <a href="index.html#val-unsafe_get"><code>unsafe_get</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span class="keyword">val</span> unsafe_get : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Unsafe version of <a href="index.html#val-get"><code>get</code></a></p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Set a bit at a specific index. See <a href="index.html#val-unsafe_set"><code>unsafe_set</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span class="keyword">val</span> unsafe_set : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-set"><code>set</code></a></p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear a bit at a specific index. See <a href="index.html#val-unsafe_clear"><code>unsafe_clear</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_clear"><a href="#val-unsafe_clear" class="anchor"></a><code><span class="keyword">val</span> unsafe_clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-clear"><code>clear</code></a></p></dd></dl><dl><dt class="spec value" id="val-setb"><a href="#val-setb" class="anchor"></a><code><span class="keyword">val</span> setb : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Set a bit at a specific index according to a boolean. See <a href="index.html#val-unsafe_setb"><code>unsafe_setb</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_setb"><a href="#val-unsafe_setb" class="anchor"></a><code><span class="keyword">val</span> unsafe_setb : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-setb"><code>setb</code></a></p></dd></dl><dl><dt class="spec value" id="val-mask"><a href="#val-mask" class="anchor"></a><code><span class="keyword">val</span> mask : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>mask i l</code> creates a mask stating at i of length l. This means that the bits of the output in the range <code>[i; i+l)</code> are ones and the others are 0.</p><p>See <a href="index.html#val-unsafe_mask"><code>unsafe_mask</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-unsafe_mask"><a href="#val-unsafe_mask" class="anchor"></a><code><span class="keyword">val</span> unsafe_mask : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-mask"><code>mask</code></a></p></dd></dl><dl><dt class="spec value" id="val-set_range"><a href="#val-set_range" class="anchor"></a><code><span class="keyword">val</span> set_range : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>set_range bf i l</code> sets the range <code>[i; i+l)</code> to ones in <code>bf</code>. See <a href="index.html#val-unsafe_set_range"><code>unsafe_set_range</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_set_range"><a href="#val-unsafe_set_range" class="anchor"></a><code><span class="keyword">val</span> unsafe_set_range : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-set_range"><code>set_range</code></a></p></dd></dl><dl><dt class="spec value" id="val-clear_range"><a href="#val-clear_range" class="anchor"></a><code><span class="keyword">val</span> clear_range : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>clear_range bf i l</code> sets the range <code>[i; i+l)</code> to zeroes in <code>bf</code>. See <a href="index.html#val-unsafe_set_range"><code>unsafe_set_range</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_clear_range"><a href="#val-unsafe_clear_range" class="anchor"></a><code><span class="keyword">val</span> unsafe_clear_range : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-clear_range"><code>clear_range</code></a></p></dd></dl><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>sub bf i l</code> outputs the range <code>[i; i+l)</code> of bf. The bits above l of the result are zeroes.</p><p>See <a href="index.html#val-unsafe_sub"><code>unsafe_sub</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_sub"><a href="#val-unsafe_sub" class="anchor"></a><code><span class="keyword">val</span> unsafe_sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-sub"><code>sub</code></a></p></dd></dl><dl><dt class="spec value" id="val-set_sub"><a href="#val-set_sub" class="anchor"></a><code><span class="keyword">val</span> set_sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>set_sub bf i l data</code> sets the <code>[i; i+l)</code> range of <code>bf</code> to <code>data</code>. The bits above <code>l</code> of <code>data</code> are ignored.</p><p>See <a href="index.html#val-unsafe_set_sub"><code>unsafe_set_sub</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_set_sub"><a href="#val-unsafe_set_sub" class="anchor"></a><code><span class="keyword">val</span> unsafe_set_sub : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-set_sub"><code>set_sub</code></a>. However the bits above l of data must be zeroes</p></dd></dl><dl><dt class="spec value" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span class="keyword">val</span> blit : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>unsafe_blit src isrc dest idest len</code> copies <code>[isrc; isrc+len)</code> of <code>src</code> into <code>[idest; idest +l)</code> of <code>dest</code>.</p><p>See <a href="index.html#val-unsafe_blit"><code>unsafe_blit</code></a></p></dd></dl><dl><dt class="spec value" id="val-unsafe_blit"><a href="#val-unsafe_blit" class="anchor"></a><code><span class="keyword">val</span> unsafe_blit : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Unsafe version of <a href="index.html#val-blit"><code>blit</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IntBits (read-dwarf.Utils.IntBits)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; IntBits</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.IntBits</span></code></h1><p>Manipulate an int as bitfield of size 31 or 63.</p><p>I'm tired of having to think about bit shifts and bitwise operations when I do that stuff</p><p>Little endian indexing (0 is the least significant bit)</p><p>Ranges are specified with and index and a length. The index must be in <code>[0,length)</code> and the length must be in <code>(0,length]</code>. Those conditions will be named &quot;valid range&quot;. Any range specified in that way can go after the end. When reading, it will behave as if it was zeroes, and on writes, all bits after the end are discarded.</p><p>All unsafe function implicitely assume that all indexes and ranges are valid. All safe functions throw if those conditions are not met.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = int</span></code></div><div class="spec-doc"><p>The type of a int as a bitfield. This is just to make signatures clearer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : int</span></code></div><div class="spec-doc"><p>The length of an integer in bits (<code>Sys.int_size</code>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-back"><a href="#val-back" class="anchor"></a><code><span><span class="keyword">val</span> back : int</span></code></div><div class="spec-doc"><p>The last index in an integer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_index"><a href="#val-check_index" class="anchor"></a><code><span><span class="keyword">val</span> check_index : <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Check that the index is valid to index an integer.</p><p>Throw <code>Invalid_argument</code> if the index is not valid</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_range"><a href="#val-check_range" class="anchor"></a><code><span><span class="keyword">val</span> check_range : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Check that the range is valid to index an integer. See module documentation (<a href="#"><code>IntBits</code></a>) for the definition of a valid range.</p><p>Throw <code>Invalid_argument</code> if the range is not valid.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Initialize an int with all zeros or all ones depending on the boolean</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Get a bit at a specific index. See <a href="#val-unsafe_get"><code>unsafe_get</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_get : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-get"><code>get</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Set a bit at a specific index. See <a href="#val-unsafe_set"><code>unsafe_set</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_set : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-set"><code>set</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear a bit at a specific index. See <a href="#val-unsafe_clear"><code>unsafe_clear</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_clear"><a href="#val-unsafe_clear" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-clear"><code>clear</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-setb"><a href="#val-setb" class="anchor"></a><code><span><span class="keyword">val</span> setb : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Set a bit at a specific index according to a boolean. See <a href="#val-unsafe_setb"><code>unsafe_setb</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_setb"><a href="#val-unsafe_setb" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_setb : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-setb"><code>setb</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mask"><a href="#val-mask" class="anchor"></a><code><span><span class="keyword">val</span> mask : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>mask i l</code> creates a mask stating at i of length l. This means that the bits of the output in the range <code>[i; i+l)</code> are ones and the others are 0.</p><p>See <a href="#val-unsafe_mask"><code>unsafe_mask</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_mask"><a href="#val-unsafe_mask" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_mask : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-mask"><code>mask</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_range"><a href="#val-set_range" class="anchor"></a><code><span><span class="keyword">val</span> set_range : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>set_range bf i l</code> sets the range <code>[i; i+l)</code> to ones in <code>bf</code>. See <a href="#val-unsafe_set_range"><code>unsafe_set_range</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_set_range"><a href="#val-unsafe_set_range" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_set_range : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-set_range"><code>set_range</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_range"><a href="#val-clear_range" class="anchor"></a><code><span><span class="keyword">val</span> clear_range : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>clear_range bf i l</code> sets the range <code>[i; i+l)</code> to zeroes in <code>bf</code>. See <a href="#val-unsafe_set_range"><code>unsafe_set_range</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_clear_range"><a href="#val-unsafe_clear_range" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_clear_range : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-clear_range"><code>clear_range</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>sub bf i l</code> outputs the range <code>[i; i+l)</code> of bf. The bits above l of the result are zeroes.</p><p>See <a href="#val-unsafe_sub"><code>unsafe_sub</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_sub"><a href="#val-unsafe_sub" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-sub"><code>sub</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_sub"><a href="#val-set_sub" class="anchor"></a><code><span><span class="keyword">val</span> set_sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>set_sub bf i l data</code> sets the <code>[i; i+l)</code> range of <code>bf</code> to <code>data</code>. The bits above <code>l</code> of <code>data</code> are ignored.</p><p>See <a href="#val-unsafe_set_sub"><code>unsafe_set_sub</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_set_sub"><a href="#val-unsafe_set_sub" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_set_sub : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-set_sub"><code>set_sub</code></a>. However the bits above l of data must be zeroes</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span><span class="keyword">val</span> blit : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p><code>unsafe_blit src isrc dest idest len</code> copies <code>[isrc; isrc+len)</code> of <code>src</code> into <code>[idest; idest +l)</code> of <code>dest</code>.</p><p>See <a href="#val-unsafe_blit"><code>unsafe_blit</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_blit"><a href="#val-unsafe_blit" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_blit : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Unsafe version of <a href="#val-blit"><code>blit</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/List/index.html b/doc/html/read-dwarf/Utils/List/index.html
index c4b6b039..a8d5600d 100644
--- a/doc/html/read-dwarf/Utils/List/index.html
+++ b/doc/html/read-dwarf/Utils/List/index.html
@@ -1,2 +1,16 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>List (read-dwarf.Utils.List)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; List</nav><h1>Module <code>Utils.List</code></h1><nav class="toc"><ul><li><a href="#iterators">Iterators</a></li><li><a href="#removing-elements">Removing elements</a></li><li><a href="#sorted-list-manipulation">Sorted list manipulation</a></li><li><a href="#sequences">Sequences</a></li><li><a href="#equality-and-comparison">Equality and comparison</a></li><li><a href="#list-monad">List monad</a></li></ul></nav></header><aside><p>Extension of the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html"><code>List</code></a> module of the standard library.</p><p>It port forward function of ocaml 4.10 among others.</p></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.List</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> list</span></code><code> = </code><table class="variant"><tr id="type-t.([])" class="anchored"><td class="def constructor"><a href="#type-t.([])" class="anchor"></a><code>| </code><code><span class="constructor">([])</span></code></td></tr><tr id="type-t.(::)" class="anchored"><td class="def constructor"><a href="#type-t.(::)" class="anchor"></a><code>| </code><code><span class="constructor">(::)</span> <span class="keyword">of</span> <span class="type-var">'a</span> * <span><span class="type-var">'a</span> list</span></code></td></tr></table></dt></dl><dl><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-compare_lengths"><a href="#val-compare_lengths" class="anchor"></a><code><span class="keyword">val</span> compare_lengths : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-compare_length_with"><a href="#val-compare_length_with" class="anchor"></a><code><span class="keyword">val</span> compare_length_with : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-cons"><a href="#val-cons" class="anchor"></a><code><span class="keyword">val</span> cons : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-hd"><a href="#val-hd" class="anchor"></a><code><span class="keyword">val</span> hd : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-tl"><a href="#val-tl" class="anchor"></a><code><span class="keyword">val</span> tl : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-nth"><a href="#val-nth" class="anchor"></a><code><span class="keyword">val</span> nth : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-nth_opt"><a href="#val-nth_opt" class="anchor"></a><code><span class="keyword">val</span> nth_opt : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-rev"><a href="#val-rev" class="anchor"></a><code><span class="keyword">val</span> rev : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : int <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-append"><a href="#val-append" class="anchor"></a><code><span class="keyword">val</span> append : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-rev_append"><a href="#val-rev_append" class="anchor"></a><code><span class="keyword">val</span> rev_append : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span class="keyword">val</span> concat : <span><span><span class="type-var">'a</span> list</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-flatten"><a href="#val-flatten" class="anchor"></a><code><span class="keyword">val</span> flatten : <span><span><span class="type-var">'a</span> list</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span></code></dt><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span></code></dt><dt class="spec value" id="val-rev_map"><a href="#val-rev_map" class="anchor"></a><code><span class="keyword">val</span> rev_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span></code></dt><dt class="spec value" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span class="keyword">val</span> filter_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span></code></dt><dt class="spec value" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span class="keyword">val</span> fold_left : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span class="keyword">val</span> fold_right : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span class="keyword">val</span> iter2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span class="keyword">val</span> map2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> list</span></code></dt><dt class="spec value" id="val-rev_map2"><a href="#val-rev_map2" class="anchor"></a><code><span class="keyword">val</span> rev_map2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> list</span></code></dt><dt class="spec value" id="val-fold_left2"><a href="#val-fold_left2" class="anchor"></a><code><span class="keyword">val</span> fold_left2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-fold_right2"><a href="#val-fold_right2" class="anchor"></a><code><span class="keyword">val</span> fold_right2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> <span>&#45;&gt;</span> <span class="type-var">'c</span></code></dt><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-for_all2"><a href="#val-for_all2" class="anchor"></a><code><span class="keyword">val</span> for_all2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-exists2"><a href="#val-exists2" class="anchor"></a><code><span class="keyword">val</span> exists2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-memq"><a href="#val-memq" class="anchor"></a><code><span class="keyword">val</span> memq : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span class="keyword">val</span> find_opt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span class="keyword">val</span> filter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span class="keyword">val</span> find_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-partition"><a href="#val-partition" class="anchor"></a><code><span class="keyword">val</span> partition : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> * <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-assoc"><a href="#val-assoc" class="anchor"></a><code><span class="keyword">val</span> assoc : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-assoc_opt"><a href="#val-assoc_opt" class="anchor"></a><code><span class="keyword">val</span> assoc_opt : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dt class="spec value" id="val-assq"><a href="#val-assq" class="anchor"></a><code><span class="keyword">val</span> assq : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-assq_opt"><a href="#val-assq_opt" class="anchor"></a><code><span class="keyword">val</span> assq_opt : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dt class="spec value" id="val-mem_assoc"><a href="#val-mem_assoc" class="anchor"></a><code><span class="keyword">val</span> mem_assoc : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-mem_assq"><a href="#val-mem_assq" class="anchor"></a><code><span class="keyword">val</span> mem_assq : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-remove_assoc"><a href="#val-remove_assoc" class="anchor"></a><code><span class="keyword">val</span> remove_assoc : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></code></dt><dt class="spec value" id="val-remove_assq"><a href="#val-remove_assq" class="anchor"></a><code><span class="keyword">val</span> remove_assq : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></code></dt><dt class="spec value" id="val-split"><a href="#val-split" class="anchor"></a><code><span class="keyword">val</span> split : <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> * <span><span class="type-var">'b</span> list</span></code></dt><dt class="spec value" id="val-combine"><a href="#val-combine" class="anchor"></a><code><span class="keyword">val</span> combine : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></code></dt><dt class="spec value" id="val-sort"><a href="#val-sort" class="anchor"></a><code><span class="keyword">val</span> sort : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-stable_sort"><a href="#val-stable_sort" class="anchor"></a><code><span class="keyword">val</span> stable_sort : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-fast_sort"><a href="#val-fast_sort" class="anchor"></a><code><span class="keyword">val</span> fast_sort : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-sort_uniq"><a href="#val-sort_uniq" class="anchor"></a><code><span class="keyword">val</span> sort_uniq : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span class="keyword">val</span> merge : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span class="type-var">'a</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-repeat"><a href="#val-repeat" class="anchor"></a><code><span class="keyword">val</span> repeat : int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p><code>repeat n a</code> return a list of <code>n</code> <code>a</code>s.</p></dd></dl><dl><dt class="spec value" id="val-set_nth"><a href="#val-set_nth" class="anchor"></a><code><span class="keyword">val</span> set_nth : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Set the nth value to the new value and return the modified list</p></dd></dl><dl><dt class="spec value" id="val-last"><a href="#val-last" class="anchor"></a><code><span class="keyword">val</span> last : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Give the last element of the list. Raise <code>Invalid_argument</code> if the list is empty.</p></dd></dl><dl><dt class="spec value" id="val-last_opt"><a href="#val-last_opt" class="anchor"></a><code><span class="keyword">val</span> last_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Give the last element of the list. Return <code>None</code> if the list is empty.</p></dd></dl><section><header><h2 id="iterators"><a href="#iterators" class="anchor"></a>Iterators</h2></header><dl><dt class="spec value" id="val-fold_left_same"><a href="#val-fold_left_same" class="anchor"></a><code><span class="keyword">val</span> fold_left_same : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Same as fold_left, but do not require a start element, instead the function start with the first element of the list: <code>fold_left_same f [b1; ...; bn] = f (... (f (f b1 b2) ...) bn</code>.</p><p>It will fail with <code>Invalid_argument</code> if the list is empty.</p><p>It can also be written as <code>fold_left_same f l = fold_left f (hd l) (tl l)</code></p></dd></dl><dl><dt class="spec value" id="val-of_array_map"><a href="#val-of_array_map" class="anchor"></a><code><span class="keyword">val</span> of_array_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Map a function at the same time as we are creating a list from an array</p><p>Warning: The function is mapped from the right to the left (in case it has side-effects).</p><p><code>of_array_map f l = of_array (Array.map f l) = map f (of_array l)</code></p></dd></dl><dl><dt class="spec value" id="val-of_array_mapi"><a href="#val-of_array_mapi" class="anchor"></a><code><span class="keyword">val</span> of_array_mapi : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Same as <a href="index.html#val-of_array_map"><code>of_array_map</code></a> but with the index</p></dd></dl><dl><dt class="spec value" id="val-concat_map_rev"><a href="#val-concat_map_rev" class="anchor"></a><code><span class="keyword">val</span> concat_map_rev : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Same as <a href="index.html#val-concat_map"><code>concat_map</code></a> then <a href="index.html#val-rev"><code>rev</code></a></p></dd></dl><dl><dt class="spec value" id="val-concat_map"><a href="#val-concat_map" class="anchor"></a><code><span class="keyword">val</span> concat_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Same as <code>map</code> then <code>concat</code>.</p><p>TODO: find a clean way of doing conditional compilation, otherwise this will shadow the official <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALconcat_map"><code>concat_map</code></a> in 4.10</p></dd></dl><dl><dt class="spec value" id="val-find_map"><a href="#val-find_map" class="anchor"></a><code><span class="keyword">val</span> find_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dd><p><code>find_map f l</code> applies <code>f</code> to the elements of <code>l</code> in order, and returns the first result of the form <code>Some v</code>, or <code>None</code> if <code>f</code> always return <code>None</code></p><p>TODO: find a clean way of doing conditional compilation, otherwise this will shadow the official <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALfind_map"><code>find_map</code></a> in 4.10</p></dd></dl><dl><dt class="spec value" id="val-filter_opt"><a href="#val-filter_opt" class="anchor"></a><code><span class="keyword">val</span> filter_opt : <span><span><span class="type-var">'a</span> option</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Takes a list of option and only keeps the <code>Some</code>. Equivalent to <code>filter_map Fun.id</code></p></dd></dl><dl><dt class="spec value" id="val-partition_map"><a href="#val-partition_map" class="anchor"></a><code><span class="keyword">val</span> partition_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> * <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>This function behaves as <code>partition</code> then a <code>map</code>. First we do a <code>partition</code> with the function assuming <code>Some</code> means <code>true</code>, then for all the extracted elements we map <code>f</code> on them and return the results.</p><p>Formally: <code>partition_map f l = (filter (fun a -&gt; f a = None) l, filter_map f l)</code></p></dd></dl></section><section><header><h2 id="removing-elements"><a href="#removing-elements" class="anchor"></a>Removing elements</h2></header><dl><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> option</span></code></dt><dd><p>Remove the first element matching the predicate. Returns <code>None</code> if no element matches the predicate</p></dd></dl><dl><dt class="spec value" id="val-drop"><a href="#val-drop" class="anchor"></a><code><span class="keyword">val</span> drop : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Drop the specified number of item from the list. If n is greater than the size of the list, then return the empty list</p></dd></dl><dl><dt class="spec value" id="val-take_rev"><a href="#val-take_rev" class="anchor"></a><code><span class="keyword">val</span> take_rev : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Take the specified number of items from the list, but reverse If n is greater than the size of the list, then return the list reversed</p><p>Tail-recursive</p></dd></dl><dl><dt class="spec value" id="val-take"><a href="#val-take" class="anchor"></a><code><span class="keyword">val</span> take : int <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dd><p>Take the specified number of items from the list. If n is greater than the size of the list, then return the list</p><p><code>l = take n l @ drop n l</code></p></dd></dl><dl><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dd><p><code>sub l pos len</code> return the sub-list of l starting at pos of length len</p></dd></dl></section><section><header><h2 id="sorted-list-manipulation"><a href="#sorted-list-manipulation" class="anchor"></a>Sorted list manipulation</h2></header><dl><dt class="spec value" id="val-merge_uniq"><a href="#val-merge_uniq" class="anchor"></a><code><span class="keyword">val</span> merge_uniq : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Same as <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALmerge"><code>merge</code></a> but duplicate elements are deleted. It is assumed that element are not duplicate in the argument (like if sorted with <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALsort_uniq"><code>sort_uniq</code></a>)</p></dd></dl></section><section><header><h2 id="sequences"><a href="#sequences" class="anchor"></a>Sequences</h2></header><dl><dt class="spec value" id="val-of_seq_rev"><a href="#val-of_seq_rev" class="anchor"></a><code><span class="keyword">val</span> of_seq_rev : <span><span class="type-var">'a</span> <a href="../index.html#module-Seq">Utils.Seq</a>.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Build a list from a sequence, but in reverse. Same as <code>of_seq</code> then <code>rev</code></p></dd></dl></section><section><header><h2 id="equality-and-comparison"><a href="#equality-and-comparison" class="anchor"></a>Equality and comparison</h2></header><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dd><p>If the list have the same length this a lexicographic compare. If one list is shorter, then the missing value a considered smaller than any actual values.</p><p>A mental model could to view list as infinite sequence of options that are <code>None</code> after the end of the list. Then it would be proper lexicographic ordering with <code>Option.compare</code></p></dd></dl></section><section><header><h2 id="list-monad"><a href="#list-monad" class="anchor"></a>List monad</h2></header><dl><dt class="spec value" id="val-bind"><a href="#val-bind" class="anchor"></a><code><span class="keyword">val</span> bind : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Monadic bind. It's just <a href="index.html#val-concat_map"><code>concat_map</code></a></p></dd></dl><dl><dt class="spec value" id="val-return"><a href="#val-return" class="anchor"></a><code><span class="keyword">val</span> return : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Monadic return</p></dd></dl><dl><dt class="spec value" id="val-short_combine"><a href="#val-short_combine" class="anchor"></a><code><span class="keyword">val</span> short_combine : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Same as <code>combine</code> but if a list is shorter then the elements of the longest list are discarded</p></dd></dl><dl><dt class="spec value" id="val-let+"><a href="#val-let+" class="anchor"></a><code><span class="keyword">val</span> let+ : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span></code></dt><dd><p>Applicative let binding. <code>let+ x = xl in e = let* x = xl in return e</code></p></dd></dl><dl><dt class="spec value" id="val-and+"><a href="#val-and+" class="anchor"></a><code><span class="keyword">val</span> and+ : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Not strict applicative merge (<a href="index.html#val-short_combine"><code>short_combine</code></a>). If both list have different length, the longer one is cropped</p></dd></dl><dl><dt class="spec value" id="val-let+!"><a href="#val-let+!" class="anchor"></a><code><span class="keyword">val</span> let+! : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterative let binding (The expression in the in must be unit). This replace implicitly a unit member of the monad (that is assumed to be uninteresting) to a true unit. In other words, it's an <code>iter</code>: <code>let+! x = l in e = List.iter (fun x -&gt; e) l</code></p></dd></dl><dl><dt class="spec value" id="val-and+!"><a href="#val-and+!" class="anchor"></a><code><span class="keyword">val</span> and+! : <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></code></dt><dd><p>Strict applicative merge (<code>combine</code>). Will throw if lists have different length</p></dd></dl><dl><dt class="spec value" id="val-let*"><a href="#val-let*" class="anchor"></a><code><span class="keyword">val</span> let* : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Monadic let binding</p></dd></dl><dl><dt class="spec value" id="val-prod"><a href="#val-prod" class="anchor"></a><code><span class="keyword">val</span> prod : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Do the Cartesian product of two lists</p></dd></dl><dl><dt class="spec value" id="val-and*"><a href="#val-and*" class="anchor"></a><code><span class="keyword">val</span> and* : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> list</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Monadic merge. <code>let* x = xl and* y = yl in ... = let* x= xl in let* y = yl in ...</code></p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>List (read-dwarf.Utils.List)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; List</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.List</span></code></h1><p>Extension of the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html"><code>List</code></a> module of the standard library.</p><p>It port forward function of ocaml 4.10 among others.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#iterators">Iterators</a></li><li><a href="#removing-elements">Removing elements</a></li><li><a href="#sorted-list-manipulation">Sorted list manipulation</a></li><li><a href="#sequences">Sequences</a></li><li><a href="#equality-and-comparison">Equality and comparison</a></li><li><a href="#list-monad">List monad</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.List <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> list</span></span><span> = </span></code><ol><li id="type-t.[]" class="def variant constructor anchored"><a href="#type-t.[]" class="anchor"></a><code><span>| </span><span><span class="constructor">[]</span></span></code></li><li id="type-t.::" class="def variant constructor anchored"><a href="#type-t.::" class="anchor"></a><code><span>| </span><span><span class="constructor">::</span> <span class="keyword">of</span> <span class="type-var">'a</span> * <span><span class="type-var">'a</span> list</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare_lengths"><a href="#val-compare_lengths" class="anchor"></a><code><span><span class="keyword">val</span> compare_lengths : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare_length_with"><a href="#val-compare_length_with" class="anchor"></a><code><span><span class="keyword">val</span> compare_length_with : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cons"><a href="#val-cons" class="anchor"></a><code><span><span class="keyword">val</span> cons : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hd"><a href="#val-hd" class="anchor"></a><code><span><span class="keyword">val</span> hd : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tl"><a href="#val-tl" class="anchor"></a><code><span><span class="keyword">val</span> tl : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nth"><a href="#val-nth" class="anchor"></a><code><span><span class="keyword">val</span> nth : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nth_opt"><a href="#val-nth_opt" class="anchor"></a><code><span><span class="keyword">val</span> nth_opt : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev"><a href="#val-rev" class="anchor"></a><code><span><span class="keyword">val</span> rev : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-append"><a href="#val-append" class="anchor"></a><code><span><span class="keyword">val</span> append : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev_append"><a href="#val-rev_append" class="anchor"></a><code><span><span class="keyword">val</span> rev_append : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><span><span><span class="type-var">'a</span> list</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten"><a href="#val-flatten" class="anchor"></a><code><span><span class="keyword">val</span> flatten : <span><span><span><span class="type-var">'a</span> list</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev_map"><a href="#val-rev_map" class="anchor"></a><code><span><span class="keyword">val</span> rev_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span><span class="keyword">val</span> filter_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left_map"><a href="#val-fold_left_map" class="anchor"></a><code><span><span class="keyword">val</span> fold_left_map : 
+  <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'acc</span> * <span><span class="type-var">'b</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span><span class="keyword">val</span> fold_right : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span><span class="keyword">val</span> iter2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rev_map2"><a href="#val-rev_map2" class="anchor"></a><code><span><span class="keyword">val</span> rev_map2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left2"><a href="#val-fold_left2" class="anchor"></a><code><span><span class="keyword">val</span> fold_left2 : 
+  <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right2"><a href="#val-fold_right2" class="anchor"></a><code><span><span class="keyword">val</span> fold_right2 : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all2"><a href="#val-for_all2" class="anchor"></a><code><span><span class="keyword">val</span> for_all2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists2"><a href="#val-exists2" class="anchor"></a><code><span><span class="keyword">val</span> exists2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-memq"><a href="#val-memq" class="anchor"></a><code><span><span class="keyword">val</span> memq : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_index"><a href="#val-find_index" class="anchor"></a><code><span><span class="keyword">val</span> find_index : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_mapi"><a href="#val-find_mapi" class="anchor"></a><code><span><span class="keyword">val</span> find_mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span><span class="keyword">val</span> filter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_all"><a href="#val-find_all" class="anchor"></a><code><span><span class="keyword">val</span> find_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filteri"><a href="#val-filteri" class="anchor"></a><code><span><span class="keyword">val</span> filteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition"><a href="#val-partition" class="anchor"></a><code><span><span class="keyword">val</span> partition : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span> * <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assoc"><a href="#val-assoc" class="anchor"></a><code><span><span class="keyword">val</span> assoc : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assoc_opt"><a href="#val-assoc_opt" class="anchor"></a><code><span><span class="keyword">val</span> assoc_opt : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assq"><a href="#val-assq" class="anchor"></a><code><span><span class="keyword">val</span> assq : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-assq_opt"><a href="#val-assq_opt" class="anchor"></a><code><span><span class="keyword">val</span> assq_opt : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_assoc"><a href="#val-mem_assoc" class="anchor"></a><code><span><span class="keyword">val</span> mem_assoc : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem_assq"><a href="#val-mem_assq" class="anchor"></a><code><span><span class="keyword">val</span> mem_assq : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_assoc"><a href="#val-remove_assoc" class="anchor"></a><code><span><span class="keyword">val</span> remove_assoc : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_assq"><a href="#val-remove_assq" class="anchor"></a><code><span><span class="keyword">val</span> remove_assq : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span> * <span><span class="type-var">'b</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-combine"><a href="#val-combine" class="anchor"></a><code><span><span class="keyword">val</span> combine : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort"><a href="#val-sort" class="anchor"></a><code><span><span class="keyword">val</span> sort : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stable_sort"><a href="#val-stable_sort" class="anchor"></a><code><span><span class="keyword">val</span> stable_sort : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fast_sort"><a href="#val-fast_sort" class="anchor"></a><code><span><span class="keyword">val</span> fast_sort : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort_uniq"><a href="#val-sort_uniq" class="anchor"></a><code><span><span class="keyword">val</span> sort_uniq : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span><span class="keyword">val</span> merge : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-repeat"><a href="#val-repeat" class="anchor"></a><code><span><span class="keyword">val</span> repeat : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p><code>repeat n a</code> return a list of <code>n</code> <code>a</code>s.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_nth"><a href="#val-set_nth" class="anchor"></a><code><span><span class="keyword">val</span> set_nth : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Set the nth value to the new value and return the modified list</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-last"><a href="#val-last" class="anchor"></a><code><span><span class="keyword">val</span> last : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Give the last element of the list. Raise <code>Invalid_argument</code> if the list is empty.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-last_opt"><a href="#val-last_opt" class="anchor"></a><code><span><span class="keyword">val</span> last_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Give the last element of the list. Return <code>None</code> if the list is empty.</p></div></div><h2 id="iterators"><a href="#iterators" class="anchor"></a>Iterators</h2><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left_same"><a href="#val-fold_left_same" class="anchor"></a><code><span><span class="keyword">val</span> fold_left_same : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Same as fold_left, but do not require a start element, instead the function start with the first element of the list: <code>fold_left_same f [b1; ...; bn] = f (... (f (f b1 b2) ...) bn</code>.</p><p>It will fail with <code>Invalid_argument</code> if the list is empty.</p><p>It can also be written as <code>fold_left_same f l = fold_left f (hd l) (tl l)</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_array_map"><a href="#val-of_array_map" class="anchor"></a><code><span><span class="keyword">val</span> of_array_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Map a function at the same time as we are creating a list from an array</p><p>Warning: The function is mapped from the right to the left (in case it has side-effects).</p><p><code>of_array_map f l = of_array (Array.map f l) = map f (of_array l)</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_array_mapi"><a href="#val-of_array_mapi" class="anchor"></a><code><span><span class="keyword">val</span> of_array_mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-of_array_map"><code>of_array_map</code></a> but with the index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_map_rev"><a href="#val-concat_map_rev" class="anchor"></a><code><span><span class="keyword">val</span> concat_map_rev : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="#val-concat_map"><code>concat_map</code></a> then <a href="#val-rev"><code>rev</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_map"><a href="#val-concat_map" class="anchor"></a><code><span><span class="keyword">val</span> concat_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <code>map</code> then <code>concat</code>.</p><p>TODO: find a clean way of doing conditional compilation, otherwise this will shadow the official <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALconcat_map"><code>concat_map</code></a> in 4.10</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_map"><a href="#val-find_map" class="anchor"></a><code><span><span class="keyword">val</span> find_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p><code>find_map f l</code> applies <code>f</code> to the elements of <code>l</code> in order, and returns the first result of the form <code>Some v</code>, or <code>None</code> if <code>f</code> always return <code>None</code></p><p>TODO: find a clean way of doing conditional compilation, otherwise this will shadow the official <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALfind_map"><code>find_map</code></a> in 4.10</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_opt"><a href="#val-filter_opt" class="anchor"></a><code><span><span class="keyword">val</span> filter_opt : <span><span><span><span class="type-var">'a</span> option</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Takes a list of option and only keeps the <code>Some</code>. Equivalent to <code>filter_map Fun.id</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition_map"><a href="#val-partition_map" class="anchor"></a><code><span><span class="keyword">val</span> partition_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>This function behaves as <code>partition</code> then a <code>map</code>. First we do a <code>partition</code> with the function assuming <code>Some</code> means <code>true</code>, then for all the extracted elements we map <code>f</code> on them and return the results.</p><p>Formally: <code>partition_map f l = (filter (fun a -&gt; f a = None) l, filter_map f l)</code></p></div></div><h2 id="removing-elements"><a href="#removing-elements" class="anchor"></a>Removing elements</h2><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> option</span></span></code></div><div class="spec-doc"><p>Remove the first element matching the predicate. Returns <code>None</code> if no element matches the predicate</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-drop"><a href="#val-drop" class="anchor"></a><code><span><span class="keyword">val</span> drop : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Drop the specified number of item from the list. If n is greater than the size of the list, then return the empty list</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take_rev"><a href="#val-take_rev" class="anchor"></a><code><span><span class="keyword">val</span> take_rev : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Take the specified number of items from the list, but reverse If n is greater than the size of the list, then return the list reversed</p><p>Tail-recursive</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take"><a href="#val-take" class="anchor"></a><code><span><span class="keyword">val</span> take : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p>Take the specified number of items from the list. If n is greater than the size of the list, then return the list</p><p><code>l = take n l @ drop n l</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div><div class="spec-doc"><p><code>sub l pos len</code> return the sub-list of l starting at pos of length len</p></div></div><h2 id="sorted-list-manipulation"><a href="#sorted-list-manipulation" class="anchor"></a>Sorted list manipulation</h2><div class="odoc-spec"><div class="spec value anchored" id="val-merge_uniq"><a href="#val-merge_uniq" class="anchor"></a><code><span><span class="keyword">val</span> merge_uniq : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALmerge"><code>merge</code></a> but duplicate elements are deleted. It is assumed that element are not duplicate in the argument (like if sorted with <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALsort_uniq"><code>sort_uniq</code></a>)</p></div></div><h2 id="sequences"><a href="#sequences" class="anchor"></a>Sequences</h2><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq_rev"><a href="#val-of_seq_rev" class="anchor"></a><code><span><span class="keyword">val</span> of_seq_rev : <span><span><span class="type-var">'a</span> <a href="../Seq/index.html#type-t">Seq.t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Build a list from a sequence, but in reverse. Same as <code>of_seq</code> then <code>rev</code></p></div></div><h2 id="equality-and-comparison"><a href="#equality-and-comparison" class="anchor"></a>Equality and comparison</h2><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>If the list have the same length this a lexicographic compare. If one list is shorter, then the missing value a considered smaller than any actual values.</p><p>A mental model could to view list as infinite sequence of options that are <code>None</code> after the end of the list. Then it would be proper lexicographic ordering with <code>Option.compare</code></p></div></div><h2 id="list-monad"><a href="#list-monad" class="anchor"></a>List monad</h2><div class="odoc-spec"><div class="spec value anchored" id="val-bind"><a href="#val-bind" class="anchor"></a><code><span><span class="keyword">val</span> bind : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Monadic bind. It's just <a href="#val-concat_map"><code>concat_map</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-return"><a href="#val-return" class="anchor"></a><code><span><span class="keyword">val</span> return : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Monadic return</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-short_combine"><a href="#val-short_combine" class="anchor"></a><code><span><span class="keyword">val</span> short_combine : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Same as <code>combine</code> but if a list is shorter then the elements of the longest list are discarded</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let+)"><a href="#val-(let+)" class="anchor"></a><code><span><span class="keyword">val</span> (let+) : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span></span></code></div><div class="spec-doc"><p>Applicative let binding. <code>let+ x = xl in e = let* x = xl in return e</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and+)"><a href="#val-(and+)" class="anchor"></a><code><span><span class="keyword">val</span> (and+) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Not strict applicative merge (<a href="#val-short_combine"><code>short_combine</code></a>). If both list have different length, the longer one is cropped</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let+!)"><a href="#val-(let+!)" class="anchor"></a><code><span><span class="keyword">val</span> (let+!) : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterative let binding (The expression in the in must be unit). This replace implicitly a unit member of the monad (that is assumed to be uninteresting) to a true unit. In other words, it's an <code>iter</code>: <code>let+! x = l in e = List.iter (fun x -&gt; e) l</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and+!)"><a href="#val-(and+!)" class="anchor"></a><code><span><span class="keyword">val</span> (and+!) : <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> list</span></span></code></div><div class="spec-doc"><p>Strict applicative merge (<code>combine</code>). Will throw if lists have different length</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let*)"><a href="#val-(let*)" class="anchor"></a><code><span><span class="keyword">val</span> (let*) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> list</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Monadic let binding</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prod"><a href="#val-prod" class="anchor"></a><code><span><span class="keyword">val</span> prod : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Do the Cartesian product of two lists</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and*)"><a href="#val-(and*)" class="anchor"></a><code><span><span class="keyword">val</span> (and*) : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Monadic merge. <code>let* x = xl and* y = yl in ... = let* x= xl in let* y = yl in ...</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hd_opt"><a href="#val-hd_opt" class="anchor"></a><code><span><span class="keyword">val</span> hd_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose"><a href="#val-transpose" class="anchor"></a><code><span><span class="keyword">val</span> transpose : <span><span class="label">defaults</span>:<span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Logs/Logger/argument-1-S/index.html b/doc/html/read-dwarf/Utils/Logs/Logger/argument-1-S/index.html
index c942c117..2d30b30d 100644
--- a/doc/html/read-dwarf/Utils/Logs/Logger/argument-1-S/index.html
+++ b/doc/html/read-dwarf/Utils/Logs/Logger/argument-1-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-S (read-dwarf.Utils.Logs.Logger.1-S)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Logs</a> &#x00BB; <a href="../index.html">Logger</a> &#x00BB; 1-S</nav><h1>Parameter <code>Logger.1-S</code></h1></header><dl><dt class="spec value" id="val-str"><a href="#val-str" class="anchor"></a><code><span class="keyword">val</span> str : string</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Utils.Logs.Logger.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">Logs</a> &#x00BB; <a href="../index.html">Logger</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Parameter <code><span>Logger.S</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-str"><a href="#val-str" class="anchor"></a><code><span><span class="keyword">val</span> str : string</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Logs/Logger/index.html b/doc/html/read-dwarf/Utils/Logs/Logger/index.html
index a6d9249d..f6d3ab9d 100644
--- a/doc/html/read-dwarf/Utils/Logs/Logger/index.html
+++ b/doc/html/read-dwarf/Utils/Logs/Logger/index.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Logger (read-dwarf.Utils.Logs.Logger)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Logs</a> &#x00BB; Logger</nav><h1>Module <code>Logs.Logger</code></h1><p>This declare a logger instance. The string parameter is the logger name. It should be the OCaml module name. The normal way of instantiating this module is:</p><pre><code class="ml">open Logs.Logger (struct
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Logger (read-dwarf.Utils.Logs.Logger)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Logs</a> &#x00BB; Logger</nav><header class="odoc-preamble"><h1>Module <code><span>Logs.Logger</span></code></h1><p>This declare a logger instance. The string parameter is the logger name. It should be the OCaml module name. The normal way of instantiating this module is:</p><pre class="language-ocaml"><code>open Logs.Logger (struct
   let str = __MODULE__
-end)</code></pre><p>This module provide a lot of logging function, They only provide a format string interface but with <a href="../../Pp/index.html#val-top"><code>Pp.top</code></a> on may print efficiently but lazily arbitrary <span class="xref-unresolved" title="unresolved reference to &quot;Pp.document&quot;"><a href="../../index.html#module-Pp"><code>Pp</code></a>.document</span> to the logs.</p><p>Some examples:</p><pre><code class="ml">warn &quot;This weird thing happened, I choose that default behavior for case %s&quot; case </code></pre><pre><code class="ml">debug &quot;Function ... received value %t&quot; Pp.(top printer object) </code></pre></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-S/index.html">S</a> : <a href="../index.html#module-type-String">String</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec value" id="val-set_level"><a href="#val-set_level" class="anchor"></a><code><span class="keyword">val</span> set_level : <a href="../index.html#type-level">level</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Override the level of this logger. It may still be overridden by the command line</p></dd></dl><dl><dt class="spec value" id="val-get_level"><a href="#val-get_level" class="anchor"></a><code><span class="keyword">val</span> get_level : unit <span>&#45;&gt;</span> <a href="../index.html#type-level">level</a></code></dt><dd><p>Get the current level</p></dd></dl><dl><dt class="spec value" id="val-log"><a href="#val-log" class="anchor"></a><code><span class="keyword">val</span> log : <a href="../index.html#type-level">level</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></code></dt><dd><p>Log a specific level using a format string</p></dd></dl><dl><dt class="spec value" id="val-log_fatal"><a href="#val-log_fatal" class="anchor"></a><code><span class="keyword">val</span> log_fatal : <span>code:int</span> <span>&#45;&gt;</span> <a href="../index.html#type-level">level</a> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../index.html#type-printf_fatal">printf_fatal</a></span></code></dt><dd><p>Log a fatal problem with format string then shutdown with <code>code</code></p></dd></dl><dl><dt class="spec value" id="val-base"><a href="#val-base" class="anchor"></a><code><span class="keyword">val</span> base : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></code></dt><dd><p>Base command line output asked for by the CLI. Level is <a href="../index.html#type-level.Base"><code>Base</code></a></p></dd></dl><dl><dt class="spec value" id="val-fail"><a href="#val-fail" class="anchor"></a><code><span class="keyword">val</span> fail : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../index.html#type-printf_fatal">printf_fatal</a></span></code></dt><dd><p>Failure due to external circumstances, generally wrong user input, then exit with code 1. Level is <a href="../index.html#type-level.Base"><code>Base</code></a></p></dd></dl><dl><dt class="spec value" id="val-err"><a href="#val-err" class="anchor"></a><code><span class="keyword">val</span> err : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></code></dt><dd><p>Declare a non-fatal internal error. Level is <a href="../index.html#type-level.Err"><code>Err</code></a></p></dd></dl><dl><dt class="spec value" id="val-fatal"><a href="#val-fatal" class="anchor"></a><code><span class="keyword">val</span> fatal : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../index.html#type-printf_fatal">printf_fatal</a></span></code></dt><dd><p>Declare a fatal internal error then exit with code 2. Level is <a href="../index.html#type-level.Err"><code>Err</code></a></p></dd></dl><dl><dt class="spec value" id="val-warn"><a href="#val-warn" class="anchor"></a><code><span class="keyword">val</span> warn : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></code></dt><dd><p>Raise a warning. Level is <a href="../index.html#type-level.Warn"><code>Warn</code></a></p></dd></dl><dl><dt class="spec value" id="val-info"><a href="#val-info" class="anchor"></a><code><span class="keyword">val</span> info : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></code></dt><dd><p>Print general information about what's happening. Level is <a href="../index.html#type-level.Info"><code>Info</code></a></p></dd></dl><dl><dt class="spec value" id="val-debug"><a href="#val-debug" class="anchor"></a><code><span class="keyword">val</span> debug : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></code></dt><dd><p>Print debugging information about what's happening. Level is <a href="../index.html#type-level.Debug"><code>Debug</code></a></p></dd></dl><dl><dt class="spec value" id="val-has_debug"><a href="#val-has_debug" class="anchor"></a><code><span class="keyword">val</span> has_debug : unit <span>&#45;&gt;</span> bool</code></dt><dd><p>Tell if debug logging is enabled</p></dd></dl></div></body></html>
\ No newline at end of file
+end)</code></pre><p>This module provide a lot of logging function, They only provide a format string interface but with <a href="../../Pp/index.html#val-top"><code>Pp.top</code></a> on may print efficiently but lazily arbitrary <a href="../../Pp/index.html#type-document"><code>Pp.document</code></a> to the logs.</p><p>Some examples:</p><pre class="language-ocaml"><code> warn &quot;This weird thing happened, I choose that default behavior for case %s&quot; case </code></pre><pre class="language-ocaml"><code> debug &quot;Function ... received value %t&quot; Pp.(top printer object) </code></pre></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-S"><a href="#argument-1-S" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-S/index.html">S</a></span><span> : <a href="../module-type-String/index.html">String</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec value anchored" id="val-set_level"><a href="#val-set_level" class="anchor"></a><code><span><span class="keyword">val</span> set_level : <span><a href="../index.html#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Override the level of this logger. It may still be overridden by the command line</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_level"><a href="#val-get_level" class="anchor"></a><code><span><span class="keyword">val</span> get_level : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="../index.html#type-level">level</a></span></code></div><div class="spec-doc"><p>Get the current level</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log"><a href="#val-log" class="anchor"></a><code><span><span class="keyword">val</span> log : <span><a href="../index.html#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></span></code></div><div class="spec-doc"><p>Log a specific level using a format string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log_fatal"><a href="#val-log_fatal" class="anchor"></a><code><span><span class="keyword">val</span> log_fatal : <span><span class="label">code</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../index.html#type-printf_fatal">printf_fatal</a></span></span></code></div><div class="spec-doc"><p>Log a fatal problem with format string then shutdown with <code>code</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-base"><a href="#val-base" class="anchor"></a><code><span><span class="keyword">val</span> base : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></span></code></div><div class="spec-doc"><p>Base command line output asked for by the CLI. Level is <a href="../index.html#type-level.Base"><code>Base</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fail"><a href="#val-fail" class="anchor"></a><code><span><span class="keyword">val</span> fail : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../index.html#type-printf_fatal">printf_fatal</a></span></span></code></div><div class="spec-doc"><p>Failure due to external circumstances, generally wrong user input, then exit with code 1. Level is <a href="../index.html#type-level.Base"><code>Base</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-err"><a href="#val-err" class="anchor"></a><code><span><span class="keyword">val</span> err : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></span></code></div><div class="spec-doc"><p>Declare a non-fatal internal error. Level is <a href="../index.html#type-level.Err"><code>Err</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fatal"><a href="#val-fatal" class="anchor"></a><code><span><span class="keyword">val</span> fatal : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../index.html#type-printf_fatal">printf_fatal</a></span></span></code></div><div class="spec-doc"><p>Declare a fatal internal error then exit with code 2. Level is <a href="../index.html#type-level.Err"><code>Err</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-warn"><a href="#val-warn" class="anchor"></a><code><span><span class="keyword">val</span> warn : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></span></code></div><div class="spec-doc"><p>Raise a warning. Level is <a href="../index.html#type-level.Warn"><code>Warn</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-info"><a href="#val-info" class="anchor"></a><code><span><span class="keyword">val</span> info : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></span></code></div><div class="spec-doc"><p>Print general information about what's happening. Level is <a href="../index.html#type-level.Info"><code>Info</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-debug"><a href="#val-debug" class="anchor"></a><code><span><span class="keyword">val</span> debug : <span><span class="type-var">'a</span> <a href="../index.html#type-printf">printf</a></span></span></code></div><div class="spec-doc"><p>Print debugging information about what's happening. Level is <a href="../index.html#type-level.Debug"><code>Debug</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-has_debug"><a href="#val-has_debug" class="anchor"></a><code><span><span class="keyword">val</span> has_debug : <span>unit <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Tell if debug logging is enabled</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Logs/index.html b/doc/html/read-dwarf/Utils/Logs/index.html
index 6d477894..874c8cb8 100644
--- a/doc/html/read-dwarf/Utils/Logs/index.html
+++ b/doc/html/read-dwarf/Utils/Logs/index.html
@@ -1,4 +1,12 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Logs (read-dwarf.Utils.Logs)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Logs</nav><h1>Module <code>Utils.Logs</code></h1></header><aside><p>This module provide a logging system for each module.</p><p>The logging system is intended to print on <code>stderr</code> or <code>stdout</code> (and maybe in file later) messages of the form:</p><pre>[Module][Level] Message here</pre><p>For example:</p><pre>[Z3][Info] Z3 server started with version 4.8.7</pre><p>If you just want to use it to log things in your own module, just insert at the start of the module the following code:</p><pre><code class="ml">open Logs.Logger (struct
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Logs (read-dwarf.Utils.Logs)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Logs</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Logs</span></code></h1><p>This module provide a logging system for each module.</p><p>The logging system is intended to print on <code>stderr</code> or <code>stdout</code> (and maybe in file later) messages of the form:</p><pre>[Module][Level] Message here</pre><p>For example:</p><pre>[Z3][Info] Z3 server started with version 4.8.7</pre><p>If you just want to use it to log things in your own module, just insert at the start of the module the following code:</p><pre class="language-ocaml"><code>open Logs.Logger (struct
   let str = __MODULE__
-end)</code></pre><p>You can then use all the function in <a href="Logger/index.html"><code>Logger</code></a> to print logging messages in your module.</p><p>The rest of this module is about manipulation log <a href="index.html#type-level"><code>level</code></a> in the different modules. You can dynamically interact with the logs level from the command line by using <span class="xref-unresolved" title="unresolved reference to &quot;CommonOpt.logs&quot;"><code>CommonOpt</code>.logs</span></p></aside><dl><dt class="spec type" id="type-printf"><a href="#type-printf" class="anchor"></a><code><span class="keyword">type</span> <span>'a printf</span></code><code> = <span><span>(<span class="type-var">'a</span>, Stdlib.out_channel, unit)</span> Stdlib.format</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>The type of normal logging function</p></dd></dl><dl><dt class="spec type" id="type-printf_fatal"><a href="#type-printf_fatal" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'b) printf_fatal</span></code><code> = <span><span>(<span class="type-var">'a</span>, Stdlib.out_channel, unit, <span class="type-var">'b</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>The type of a failing logging function, that will exit after printing it's message</p></dd></dl><dl><dt class="spec type" id="type-level"><a href="#type-level" class="anchor"></a><code><span class="keyword">type</span> level</code><code> = </code><table class="variant"><tr id="type-level.Base" class="anchored"><td class="def constructor"><a href="#type-level.Base" class="anchor"></a><code>| </code><code><span class="constructor">Base</span></code></td><td class="doc"><p>The actual output. The only thing printed in quiet mode. Should only appear in <a href="../../CLI.html"><code>CLI</code></a> modules</p></td></tr><tr id="type-level.Err" class="anchored"><td class="def constructor"><a href="#type-level.Err" class="anchor"></a><code>| </code><code><span class="constructor">Err</span></code></td><td class="doc"><p>An error message</p></td></tr><tr id="type-level.Warn" class="anchored"><td class="def constructor"><a href="#type-level.Warn" class="anchor"></a><code>| </code><code><span class="constructor">Warn</span></code></td><td class="doc"><p>An warning</p></td></tr><tr id="type-level.Info" class="anchored"><td class="def constructor"><a href="#type-level.Info" class="anchor"></a><code>| </code><code><span class="constructor">Info</span></code></td><td class="doc"><p>Details on what happens that should be understandable if the person do not know the corresponding module</p></td></tr><tr id="type-level.Debug" class="anchored"><td class="def constructor"><a href="#type-level.Debug" class="anchor"></a><code>| </code><code><span class="constructor">Debug</span></code></td><td class="doc"><p>Everything happening in detail</p></td></tr></table></dt><dd><p>The type of log level</p></dd></dl><dl><dt class="spec value" id="val-pp_level"><a href="#val-pp_level" class="anchor"></a><code><span class="keyword">val</span> pp_level : <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty prints a level</p></dd></dl><dl><dt class="spec value" id="val-level_to_string"><a href="#val-level_to_string" class="anchor"></a><code><span class="keyword">val</span> level_to_string : <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert level to string</p></dd></dl><dl><dt class="spec value" id="val-level_to_header"><a href="#val-level_to_header" class="anchor"></a><code><span class="keyword">val</span> level_to_header : <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Convert level to string header like <code>&quot;[Error]&quot;</code>. <a href="index.html#type-level.Base"><code>Base</code></a> is the empty string</p></dd></dl><dl><dt class="spec value" id="val-set_default_level"><a href="#val-set_default_level" class="anchor"></a><code><span class="keyword">val</span> set_default_level : <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set a default level to all the modules. Erase local customized levels</p></dd></dl><dl><dt class="spec value" id="val-set_level"><a href="#val-set_level" class="anchor"></a><code><span class="keyword">val</span> set_level : string <span>&#45;&gt;</span> <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set level of a module by name</p></dd></dl><dl><dt class="spec value" id="val-level_conv"><a href="#val-level_conv" class="anchor"></a><code><span class="keyword">val</span> level_conv : <span><a href="index.html#type-level">level</a> Cmdliner.Arg.conv</span></code></dt><dd><p>Parser for log level on command line</p></dd></dl><dl><dt class="spec value" id="val-set_stdout_level"><a href="#val-set_stdout_level" class="anchor"></a><code><span class="keyword">val</span> set_stdout_level : <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set level below which the output goes to stdout</p></dd></dl><div class="spec module-type" id="module-type-String"><a href="#module-type-String" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-String/index.html">String</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec module" id="module-Logger"><a href="#module-Logger" class="anchor"></a><code><span class="keyword">module</span> <a href="Logger/index.html">Logger</a> : <span class="keyword">functor</span> (<a href="Logger/argument-1-S/index.html">S</a> : <a href="index.html#module-type-String">String</a>) <span>&#45;&gt;</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>This declare a logger instance. The string parameter is the logger name. It should be the OCaml module name. The normal way of instantiating this module is:</p></dd></dl><dl><dt class="spec value" id="val-process_opts"><a href="#val-process_opts" class="anchor"></a><code><span class="keyword">val</span> process_opts : bool <span>&#45;&gt;</span> <span>bool list</span> <span>&#45;&gt;</span> <span>string list</span> <span>&#45;&gt;</span> <span>string list</span> <span>&#45;&gt;</span> <a href="index.html#type-level">level</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <span>unit Cmdliner.Term.t</span></code></dt></dl></div></body></html>
\ No newline at end of file
+end)</code></pre><p>You can then use all the function in <a href="Logger/index.html"><code>Logger</code></a> to print logging messages in your module.</p><p>The rest of this module is about manipulation log <a href="#type-level"><code>level</code></a> in the different modules. You can dynamically interact with the logs level from the command line by using <code>CommonOpt.logs</code></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-printf"><a href="#type-printf" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a printf</span></span><span> = <span><span><span>(<span class="type-var">'a</span>, <span class="xref-unresolved">Stdlib</span>.out_channel, unit)</span> <span class="xref-unresolved">Stdlib</span>.format</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>The type of normal logging function</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-printf_fatal"><a href="#type-printf_fatal" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'b) printf_fatal</span></span><span> =
+  <span><span><span>(<span class="type-var">'a</span>, <span class="xref-unresolved">Stdlib</span>.out_channel, unit, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>The type of a failing logging function, that will exit after printing it's message</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-level"><a href="#type-level" class="anchor"></a><code><span><span class="keyword">type</span> level</span><span> = </span></code><ol><li id="type-level.Base" class="def variant constructor anchored"><a href="#type-level.Base" class="anchor"></a><code><span>| </span><span><span class="constructor">Base</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>The actual output. The only thing printed in quiet mode. Should only appear in <a href="../../CLI.html"><code>CLI</code></a> modules</p><span class="comment-delim">*)</span></div></li><li id="type-level.Err" class="def variant constructor anchored"><a href="#type-level.Err" class="anchor"></a><code><span>| </span><span><span class="constructor">Err</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>An error message</p><span class="comment-delim">*)</span></div></li><li id="type-level.Warn" class="def variant constructor anchored"><a href="#type-level.Warn" class="anchor"></a><code><span>| </span><span><span class="constructor">Warn</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>An warning</p><span class="comment-delim">*)</span></div></li><li id="type-level.Info" class="def variant constructor anchored"><a href="#type-level.Info" class="anchor"></a><code><span>| </span><span><span class="constructor">Info</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Details on what happens that should be understandable if the person do not know the corresponding module</p><span class="comment-delim">*)</span></div></li><li id="type-level.Debug" class="def variant constructor anchored"><a href="#type-level.Debug" class="anchor"></a><code><span>| </span><span><span class="constructor">Debug</span></span></code><div class="def-doc"><span class="comment-delim">(*</span><p>Everything happening in detail</p><span class="comment-delim">*)</span></div></li></ol></div><div class="spec-doc"><p>The type of log level</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp_level"><a href="#val-pp_level" class="anchor"></a><code><span><span class="keyword">val</span> pp_level : <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty prints a level</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-level_to_string"><a href="#val-level_to_string" class="anchor"></a><code><span><span class="keyword">val</span> level_to_string : <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert level to string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-level_to_header"><a href="#val-level_to_header" class="anchor"></a><code><span><span class="keyword">val</span> level_to_header : <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert level to string header like <code>&quot;[Error]&quot;</code>. <a href="#type-level.Base"><code>Base</code></a> is the empty string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_default_level"><a href="#val-set_default_level" class="anchor"></a><code><span><span class="keyword">val</span> set_default_level : <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set a default level to all the modules. Erase local customized levels</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_level"><a href="#val-set_level" class="anchor"></a><code><span><span class="keyword">val</span> set_level : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set level of a module by name</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-level_conv"><a href="#val-level_conv" class="anchor"></a><code><span><span class="keyword">val</span> level_conv : <span><a href="#type-level">level</a> <span class="xref-unresolved">Cmdliner</span>.Arg.conv</span></span></code></div><div class="spec-doc"><p>Parser for log level on command line</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_stdout_level"><a href="#val-set_stdout_level" class="anchor"></a><code><span><span class="keyword">val</span> set_stdout_level : <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set level below which the output goes to stdout</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-String"><a href="#module-type-String" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-String/index.html">String</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Logger"><a href="#module-Logger" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Logger/index.html">Logger</a></span><span> (<a href="Logger/argument-1-S/index.html">S</a> : <a href="module-type-String/index.html">String</a>) : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This declare a logger instance. The string parameter is the logger name. It should be the OCaml module name. The normal way of instantiating this module is:</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-process_opts"><a href="#val-process_opts" class="anchor"></a><code><span><span class="keyword">val</span> process_opts : 
+  <span>bool <span class="arrow">&#45;&gt;</span></span>
+  <span><span>bool list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-level">level</a> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-term"><a href="#val-term" class="anchor"></a><code><span><span class="keyword">val</span> term : <span>unit <span class="xref-unresolved">Cmdliner</span>.Term.t</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Logs/module-type-String/index.html b/doc/html/read-dwarf/Utils/Logs/module-type-String/index.html
index db2bc1d0..3fe2f45c 100644
--- a/doc/html/read-dwarf/Utils/Logs/module-type-String/index.html
+++ b/doc/html/read-dwarf/Utils/Logs/module-type-String/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>String (read-dwarf.Utils.Logs.String)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Logs</a> &#x00BB; String</nav><h1>Module type <code>Logs.String</code></h1></header><dl><dt class="spec value" id="val-str"><a href="#val-str" class="anchor"></a><code><span class="keyword">val</span> str : string</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>String (read-dwarf.Utils.Logs.String)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Logs</a> &#x00BB; String</nav><header class="odoc-preamble"><h1>Module type <code><span>Logs.String</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-str"><a href="#val-str" class="anchor"></a><code><span><span class="keyword">val</span> str : string</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Option/index.html b/doc/html/read-dwarf/Utils/Option/index.html
index 612e64b4..c443cd3f 100644
--- a/doc/html/read-dwarf/Utils/Option/index.html
+++ b/doc/html/read-dwarf/Utils/Option/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Option (read-dwarf.Utils.Option)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Option</nav><h1>Module <code>Utils.Option</code></h1><nav class="toc"><ul><li><a href="#utility">Utility</a></li><li><a href="#monadic-bindings">Monadic bindings</a></li><li><a href="#lists">Lists</a></li><li><a href="#pairs">Pairs</a></li></ul></nav></header><aside><p>This module extends the base OCaml API of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Option.html"><code>Option</code></a>.</p><p>In particular, it adds:</p><ul><li>Monadic bindings</li><li>Option merging</li><li>Option lifting of list and pairs.</li></ul></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> Stdlib.Option</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> option</span></code><code> = </code><table class="variant"><tr id="type-t.None" class="anchored"><td class="def constructor"><a href="#type-t.None" class="anchor"></a><code>| </code><code><span class="constructor">None</span></code></td></tr><tr id="type-t.Some" class="anchored"><td class="def constructor"><a href="#type-t.Some" class="anchor"></a><code>| </code><code><span class="constructor">Some</span> <span class="keyword">of</span> <span class="type-var">'a</span></code></td></tr></table></dt></dl><dl><dt class="spec value" id="val-none"><a href="#val-none" class="anchor"></a><code><span class="keyword">val</span> none : <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-some"><a href="#val-some" class="anchor"></a><code><span class="keyword">val</span> some : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-value"><a href="#val-value" class="anchor"></a><code><span class="keyword">val</span> value : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span>default:<span class="type-var">'a</span></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-bind"><a href="#val-bind" class="anchor"></a><code><span class="keyword">val</span> bind : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dt class="spec value" id="val-join"><a href="#val-join" class="anchor"></a><code><span class="keyword">val</span> join : <span><span><span class="type-var">'a</span> option</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <span>none:<span class="type-var">'a</span></span> <span>&#45;&gt;</span> <span>some:<span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-is_none"><a href="#val-is_none" class="anchor"></a><code><span class="keyword">val</span> is_none : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-is_some"><a href="#val-is_some" class="anchor"></a><code><span class="keyword">val</span> is_some : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-to_result"><a href="#val-to_result" class="anchor"></a><code><span class="keyword">val</span> to_result : <span>none:<span class="type-var">'e</span></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'e</span>)</span> Stdlib.result</span></code></dt><dt class="spec value" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span class="keyword">val</span> to_list : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> Stdlib.Seq.t</span></code></dt></dl></details></div></div></div><section><header><h2 id="utility"><a href="#utility" class="anchor"></a>Utility</h2></header><dl><dt class="spec value" id="val-take_first"><a href="#val-take_first" class="anchor"></a><code><span class="keyword">val</span> take_first : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Take the value in the first argument if there is one, otherwise take the value in the second argument, otherwise <code>None</code></p></dd></dl><dl><dt class="spec value" id="val-(|||)"><a href="#val-(|||)" class="anchor"></a><code><span class="keyword">val</span> (|||) : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p><a href="index.html#val-take_first"><code>take_first</code></a> as an operator:</p><p>Behave like boolean or but keep the value of the first option that gave true. This is associative but obviously not commutative.</p></dd></dl><dl><dt class="spec value" id="val-take_first_list"><a href="#val-take_first_list" class="anchor"></a><code><span class="keyword">val</span> take_first_list : <span><span><span class="type-var">'a</span> option</span> list</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Take the value of the first <code>Some</code> in the list. returns <code>None</code> if all the option were <code>None</code></p></dd></dl><dl><dt class="spec value" id="val-take_all"><a href="#val-take_all" class="anchor"></a><code><span class="keyword">val</span> take_all : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></code></dt><dd><p>If both option have values, give <code>Some</code> of the pair, otherwise <code>None</code></p></dd></dl><dl><dt class="spec value" id="val-(&amp;&amp;&amp;)"><a href="#val-(&amp;&amp;&amp;)" class="anchor"></a><code><span class="keyword">val</span> (&amp;&amp;&amp;) : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></code></dt><dd><p>Take_all as an operator:</p><p>Behave like boolean and but keep all the value of the options This is not associative because at type level (a * b) * c is not a * (b * c). Using monadic bindings is recommended for more that 2 operands.</p></dd></dl><dl><dt class="spec value" id="val-value_fail"><a href="#val-value_fail" class="anchor"></a><code><span class="keyword">val</span> value_fail : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, unit, string, <span class="type-var">'a</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>Expect the option to contain a value and fails (<code>Failure</code>) otherwise. The format string specify the content of the failure</p></dd></dl><dl><dt class="spec value" id="val-value_fun"><a href="#val-value_fun" class="anchor"></a><code><span class="keyword">val</span> value_fun : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span>default:<span>(unit <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Like Stdlib.Option.value but the default is a called function, that can throw instead of giving a value</p></dd></dl><dl><dt class="spec value" id="val-of_bool"><a href="#val-of_bool" class="anchor"></a><code><span class="keyword">val</span> of_bool : <span>some:<span class="type-var">'a</span></span> <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Create an option from a bool, with the some value</p></dd></dl><dl><dt class="spec value" id="val-of_bool_fun"><a href="#val-of_bool_fun" class="anchor"></a><code><span class="keyword">val</span> of_bool_fun : <span>some:<span>(unit <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span></span> <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Create an option from a bool, with the some value as computed by the some function</p></dd></dl><dl><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> bool</code></dt><dd><p><code>for_all p o = fold ~none:true ~some:p</code></p></dd></dl><dl><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> bool</code></dt><dd><p><code>exists p o = fold ~none:false ~some:p</code></p></dd></dl><dl><dt class="spec value" id="val-guard"><a href="#val-guard" class="anchor"></a><code><span class="keyword">val</span> guard : bool <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Return the second argument if the first is <code>true</code>, otherwise <code>None</code></p></dd></dl><dl><dt class="spec value" id="val-guardn"><a href="#val-guardn" class="anchor"></a><code><span class="keyword">val</span> guardn : bool <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Return the second argument if the first is <code>false</code>, otherwise <code>None</code></p></dd></dl></section><section><header><h2 id="monadic-bindings"><a href="#monadic-bindings" class="anchor"></a>Monadic bindings</h2></header><dl><dt class="spec value" id="val-let+"><a href="#val-let+" class="anchor"></a><code><span class="keyword">val</span> let+ : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dd><p>Applicative let.</p><p><code>let+ x = mx in e</code> is <code>Option.map (fun x -&gt; e) mx</code></p></dd></dl><dl><dt class="spec value" id="val-and+"><a href="#val-and+" class="anchor"></a><code><span class="keyword">val</span> and+ : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></code></dt><dd><p>Applicative and.</p><p><code>let+ x = mx and+ y = my in e</code> give <code>Some e</code> if both <code>mx</code> and <code>my</code> were <code>Some</code>s.</p></dd></dl><dl><dt class="spec value" id="val-let+!"><a href="#val-let+!" class="anchor"></a><code><span class="keyword">val</span> let+! : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter applicative let.</p><p><code>let+! x = mx in e</code> runs <code>e</code> if <code>mx</code> contained a value i.e <code>Option.iter (fun x -&gt; e) mx</code></p></dd></dl><dl><dt class="spec value" id="val-let*"><a href="#val-let*" class="anchor"></a><code><span class="keyword">val</span> let* : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dd><p>Monadic let: <code>let* x = mx in e</code> is <code>Option.bind mx (fun x -&gt; e)</code></p></dd></dl><dl><dt class="spec value" id="val-and*"><a href="#val-and*" class="anchor"></a><code><span class="keyword">val</span> and* : <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></code></dt><dd><p>Monadic and: <code>let* x = mx and* y = my in e</code> is <code>let* x = mx in let* y = my in e</code></p></dd></dl></section><section><header><h2 id="lists"><a href="#lists" class="anchor"></a>Lists</h2></header><dl><dt class="spec value" id="val-lift"><a href="#val-lift" class="anchor"></a><code><span class="keyword">val</span> lift : <span><span><span class="type-var">'a</span> option</span> list</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'a</span> list</span> option</span></code></dt><dd><p>Commute the list and the option. If the list contains one <code>None</code> then the result is <code>None</code>. If you want to keep all the <code>Some</code> value, use <span class="xref-unresolved" title="unresolved reference to &quot;List.filter_map&quot;"><a href="../index.html#module-List"><code>List</code></a>.filter_map</span>.</p><p>This can be condidered as a list-wide <a href="index.html#val-take_all"><code>take_all</code></a>. A list-wide <a href="index.html#val-take_first"><code>take_first</code></a> would be <a href="../List/index.html#val-find_map"><code>List.find_map</code></a></p></dd></dl><dl><dt class="spec value" id="val-map_lift"><a href="#val-map_lift" class="anchor"></a><code><span class="keyword">val</span> map_lift : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <span><span><span class="type-var">'b</span> list</span> option</span></code></dt><dd><p>The same as a List.map and then a <a href="index.html#val-lift"><code>lift</code></a></p></dd></dl></section><section><header><h2 id="pairs"><a href="#pairs" class="anchor"></a>Pairs</h2></header><dl><dt class="spec value" id="val-lift_pair"><a href="#val-lift_pair" class="anchor"></a><code><span class="keyword">val</span> lift_pair : <span>(<span><span class="type-var">'a</span> option</span> * <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></code></dt><dd><p>Lift a pair of options to an option of pair. It is the same as <a href="index.html#val-take_all"><code>take_all</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-unlift_pair"><a href="#val-unlift_pair" class="anchor"></a><code><span class="keyword">val</span> unlift_pair : <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> * <span><span class="type-var">'b</span> option</span></code></dt><dd><p>Unlift an option of pair to a pair of options</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Option (read-dwarf.Utils.Option)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Option</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Option</span></code></h1><p>This module extends the base OCaml API of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Option.html"><code>Option</code></a>.</p><p>In particular, it adds:</p><ul><li>Monadic bindings</li><li>Option merging</li><li>Option lifting of list and pairs.</li></ul></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#utility">Utility</a></li><li><a href="#monadic-bindings">Monadic bindings</a></li><li><a href="#lists">Lists</a></li><li><a href="#pairs">Pairs</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="xref-unresolved">Stdlib</span>.Option</span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> option</span></span><span> = </span></code><ol><li id="type-t.None" class="def variant constructor anchored"><a href="#type-t.None" class="anchor"></a><code><span>| </span><span><span class="constructor">None</span></span></code></li><li id="type-t.Some" class="def variant constructor anchored"><a href="#type-t.Some" class="anchor"></a><code><span>| </span><span><span class="constructor">Some</span> <span class="keyword">of</span> <span class="type-var">'a</span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-none"><a href="#val-none" class="anchor"></a><code><span><span class="keyword">val</span> none : <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-some"><a href="#val-some" class="anchor"></a><code><span><span class="keyword">val</span> some : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-value"><a href="#val-value" class="anchor"></a><code><span><span class="keyword">val</span> value : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">default</span>:<span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bind"><a href="#val-bind" class="anchor"></a><code><span><span class="keyword">val</span> bind : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-join"><a href="#val-join" class="anchor"></a><code><span><span class="keyword">val</span> join : <span><span><span><span class="type-var">'a</span> option</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span class="label">none</span>:<span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">some</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_none"><a href="#val-is_none" class="anchor"></a><code><span><span class="keyword">val</span> is_none : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_some"><a href="#val-is_some" class="anchor"></a><code><span><span class="keyword">val</span> is_some : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_result"><a href="#val-to_result" class="anchor"></a><code><span><span class="keyword">val</span> to_result : <span><span class="label">none</span>:<span class="type-var">'e</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'e</span>)</span> <span class="xref-unresolved">Stdlib</span>.result</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div></details></div><h2 id="utility"><a href="#utility" class="anchor"></a>Utility</h2><div class="odoc-spec"><div class="spec value anchored" id="val-take_first"><a href="#val-take_first" class="anchor"></a><code><span><span class="keyword">val</span> take_first : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Take the value in the first argument if there is one, otherwise take the value in the second argument, otherwise <code>None</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(|||)"><a href="#val-(|||)" class="anchor"></a><code><span><span class="keyword">val</span> (|||) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p><a href="#val-take_first"><code>take_first</code></a> as an operator:</p><p>Behave like boolean or but keep the value of the first option that gave true. This is associative but obviously not commutative.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take_first_list"><a href="#val-take_first_list" class="anchor"></a><code><span><span class="keyword">val</span> take_first_list : <span><span><span><span class="type-var">'a</span> option</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Take the value of the first <code>Some</code> in the list. returns <code>None</code> if all the option were <code>None</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take_all"><a href="#val-take_all" class="anchor"></a><code><span><span class="keyword">val</span> take_all : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></span></code></div><div class="spec-doc"><p>If both option have values, give <code>Some</code> of the pair, otherwise <code>None</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(&amp;&amp;&amp;)"><a href="#val-(&amp;&amp;&amp;)" class="anchor"></a><code><span><span class="keyword">val</span> (&amp;&amp;&amp;) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></span></code></div><div class="spec-doc"><p>Take_all as an operator:</p><p>Behave like boolean and but keep all the value of the options This is not associative because at type level (a * b) * c is not a * (b * c). Using monadic bindings is recommended for more that 2 operands.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-value_fail"><a href="#val-value_fail" class="anchor"></a><code><span><span class="keyword">val</span> value_fail : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<span class="type-var">'b</span>, unit, string, <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Expect the option to contain a value and fails (<code>Failure</code>) otherwise. The format string specify the content of the failure</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-value_fun"><a href="#val-value_fun" class="anchor"></a><code><span><span class="keyword">val</span> value_fun : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">default</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Like Stdlib.Option.value but the default is a called function, that can throw instead of giving a value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bool"><a href="#val-of_bool" class="anchor"></a><code><span><span class="keyword">val</span> of_bool : <span><span class="label">some</span>:<span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Create an option from a bool, with the some value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bool_fun"><a href="#val-of_bool_fun" class="anchor"></a><code><span><span class="keyword">val</span> of_bool_fun : <span><span class="label">some</span>:<span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Create an option from a bool, with the some value as computed by the some function</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p><code>for_all p o = fold ~none:true ~some:p</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p><code>exists p o = fold ~none:false ~some:p</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-guard"><a href="#val-guard" class="anchor"></a><code><span><span class="keyword">val</span> guard : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Return the second argument if the first is <code>true</code>, otherwise <code>None</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-guardn"><a href="#val-guardn" class="anchor"></a><code><span><span class="keyword">val</span> guardn : <span>bool <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Return the second argument if the first is <code>false</code>, otherwise <code>None</code></p></div></div><h2 id="monadic-bindings"><a href="#monadic-bindings" class="anchor"></a>Monadic bindings</h2><div class="odoc-spec"><div class="spec value anchored" id="val-(let+)"><a href="#val-(let+)" class="anchor"></a><code><span><span class="keyword">val</span> (let+) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p>Applicative let.</p><p><code>let+ x = mx in e</code> is <code>Option.map (fun x -&gt; e) mx</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and+)"><a href="#val-(and+)" class="anchor"></a><code><span><span class="keyword">val</span> (and+) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></span></code></div><div class="spec-doc"><p>Applicative and.</p><p><code>let+ x = mx and+ y = my in e</code> give <code>Some e</code> if both <code>mx</code> and <code>my</code> were <code>Some</code>s.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let+!)"><a href="#val-(let+!)" class="anchor"></a><code><span><span class="keyword">val</span> (let+!) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter applicative let.</p><p><code>let+! x = mx in e</code> runs <code>e</code> if <code>mx</code> contained a value i.e <code>Option.iter (fun x -&gt; e) mx</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(let*)"><a href="#val-(let*)" class="anchor"></a><code><span><span class="keyword">val</span> (let*) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p>Monadic let: <code>let* x = mx in e</code> is <code>Option.bind mx (fun x -&gt; e)</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(and*)"><a href="#val-(and*)" class="anchor"></a><code><span><span class="keyword">val</span> (and*) : <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></span></code></div><div class="spec-doc"><p>Monadic and: <code>let* x = mx and* y = my in e</code> is <code>let* x = mx in let* y = my in e</code></p></div></div><h2 id="lists"><a href="#lists" class="anchor"></a>Lists</h2><div class="odoc-spec"><div class="spec value anchored" id="val-lift"><a href="#val-lift" class="anchor"></a><code><span><span class="keyword">val</span> lift : <span><span><span><span class="type-var">'a</span> option</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> option</span></span></code></div><div class="spec-doc"><p>Commute the list and the option. If the list contains one <code>None</code> then the result is <code>None</code>. If you want to keep all the <code>Some</code> value, use <a href="../List/index.html#val-filter_map"><code>List.filter_map</code></a>.</p><p>This can be condidered as a list-wide <a href="#val-take_all"><code>take_all</code></a>. A list-wide <a href="#val-take_first"><code>take_first</code></a> would be <a href="../List/index.html#val-find_map"><code>List.find_map</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_lift"><a href="#val-map_lift" class="anchor"></a><code><span><span class="keyword">val</span> map_lift : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> list</span> option</span></span></code></div><div class="spec-doc"><p>The same as a List.map and then a <a href="#val-lift"><code>lift</code></a></p></div></div><h2 id="pairs"><a href="#pairs" class="anchor"></a>Pairs</h2><div class="odoc-spec"><div class="spec value anchored" id="val-lift_pair"><a href="#val-lift_pair" class="anchor"></a><code><span><span class="keyword">val</span> lift_pair : <span><span>(<span><span class="type-var">'a</span> option</span> * <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span></span></code></div><div class="spec-doc"><p>Lift a pair of options to an option of pair. It is the same as <a href="#val-take_all"><code>take_all</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unlift_pair"><a href="#val-unlift_pair" class="anchor"></a><code><span><span class="keyword">val</span> unlift_pair : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span> * <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p>Unlift an option of pair to a pair of options</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Pair/index.html b/doc/html/read-dwarf/Utils/Pair/index.html
index 01057086..164dc1ef 100644
--- a/doc/html/read-dwarf/Utils/Pair/index.html
+++ b/doc/html/read-dwarf/Utils/Pair/index.html
@@ -1,2 +1,12 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Pair (read-dwarf.Utils.Pair)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Pair</nav><h1>Module <code>Utils.Pair</code></h1></header><aside><p>This module contain random utility functions dealing with pairs</p></aside><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'d</span>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'c</span> * <span class="type-var">'d</span></code></dt><dd><p>Map each function on one side of the pair</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter each function on one side of the pair</p></dd></dl><dl><dt class="spec value" id="val-swap"><a href="#val-swap" class="anchor"></a><code><span class="keyword">val</span> swap : <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> * <span class="type-var">'a</span></code></dt><dd><p>Swap the element of a pair</p></dd></dl><dl><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <span>?&#8288;fst:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span></span> <span>&#45;&gt;</span> <span>?&#8288;snd:<span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> int)</span></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> int</code></dt><dd><p>Compare a pair using provided comparison function. Both <code>fst</code> and <code>snd</code> default to the polymorphic compare</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span>?&#8288;fst:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>?&#8288;snd:<span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span></span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Test pair equality using provided equality function. Both <code>fst</code> and <code>snd</code> default to the polymorphic equality</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> * <span class="type-var">'b</span></code></dt><dd><p>Just build the pair, not useful on it's own but <code>List.combine</code> is just <code>List.map2 Pair.make</code>, and there are some other cases where it is handy for high-order programming</p></dd></dl><dl><dt class="spec value" id="val-split"><a href="#val-split" class="anchor"></a><code><span class="keyword">val</span> split : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> * <span class="type-var">'a</span></code></dt><dd><p>Just build a pair with twice the element. Useful in high order programming</p></dd></dl><dl><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check that both individual predicates hold</p></dd></dl><dl><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check that at least one of the individual predicates holds</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Pair (read-dwarf.Utils.Pair)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Pair</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Pair</span></code></h1><p>This module contain random utility functions dealing with pairs</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'d</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span> * <span class="type-var">'d</span></span></code></div><div class="spec-doc"><p>Map each function on one side of the pair</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter each function on one side of the pair</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-swap"><a href="#val-swap" class="anchor"></a><code><span><span class="keyword">val</span> swap : <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span> * <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Swap the element of a pair</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : 
+  <span><span class="optlabel">?fst</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?snd</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  int</span></code></div><div class="spec-doc"><p>Compare a pair using provided comparison function. Both <code>fst</code> and <code>snd</code> default to the polymorphic compare</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : 
+  <span><span class="optlabel">?fst</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?snd</span>:<span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  bool</span></code></div><div class="spec-doc"><p>Test pair equality using provided equality function. Both <code>fst</code> and <code>snd</code> default to the polymorphic equality</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span> * <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Just build the pair, not useful on it's own but <code>List.combine</code> is just <code>List.map2 Pair.make</code>, and there are some other cases where it is handy for high-order programming</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span> * <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Just build a pair with twice the element. Useful in high order programming</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check that both individual predicates hold</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check that at least one of the individual predicates holds</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Pp/class-type-custom/index.html b/doc/html/read-dwarf/Utils/Pp/class-type-custom/index.html
index 74f26f9a..60572228 100644
--- a/doc/html/read-dwarf/Utils/Pp/class-type-custom/index.html
+++ b/doc/html/read-dwarf/Utils/Pp/class-type-custom/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>custom (read-dwarf.Utils.Pp.custom)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Pp</a> &#x00BB; custom</nav><h1>Class type <code>Pp.custom</code></h1></header><dl><dt class="spec method" id="method-compact"><a href="#method-compact" class="anchor"></a><code><span class="keyword">method</span> compact : <a href="../class-type-output/index.html">output</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec method" id="method-pretty"><a href="#method-pretty" class="anchor"></a><code><span class="keyword">method</span> pretty : <a href="../class-type-output/index.html">output</a> <span>&#45;&gt;</span> <a href="../index.html#type-state">state</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> unit</code></dt><dt class="spec method" id="method-requirement"><a href="#method-requirement" class="anchor"></a><code><span class="keyword">method</span> requirement : <a href="../index.html#type-requirement">requirement</a></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>custom (read-dwarf.Utils.Pp.custom)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Pp</a> &#x00BB; custom</nav><header class="odoc-preamble"><h1>Class type <code><span>Pp.custom</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec method anchored" id="method-compact"><a href="#method-compact" class="anchor"></a><code><span><span class="keyword">method</span> compact : <span><span class="xref-unresolved">output</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec method anchored" id="method-pretty"><a href="#method-pretty" class="anchor"></a><code><span><span class="keyword">method</span> pretty : <span><span class="xref-unresolved">output</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="../index.html#type-state">state</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec method anchored" id="method-requirement"><a href="#method-requirement" class="anchor"></a><code><span><span class="keyword">method</span> requirement : <a href="../index.html#type-requirement">requirement</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Pp/class-type-output/index.html b/doc/html/read-dwarf/Utils/Pp/class-type-output/index.html
index 5b213ff7..265c379e 100644
--- a/doc/html/read-dwarf/Utils/Pp/class-type-output/index.html
+++ b/doc/html/read-dwarf/Utils/Pp/class-type-output/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>output (read-dwarf.Utils.Pp.output)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Pp</a> &#x00BB; output</nav><h1>Class type <code>Pp.output</code></h1></header><dl><dt class="spec method" id="method-char"><a href="#method-char" class="anchor"></a><code><span class="keyword">method</span> char : char <span>&#45;&gt;</span> unit</code></dt><dt class="spec method" id="method-substring"><a href="#method-substring" class="anchor"></a><code><span class="keyword">method</span> substring : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>output (read-dwarf.Utils.Pp.output)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">Pp</a> &#x00BB; output</nav><header class="odoc-preamble"><h1>Class type <code><span>Pp.output</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec method anchored" id="method-char"><a href="#method-char" class="anchor"></a><code><span><span class="keyword">method</span> char : <span>char <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec method anchored" id="method-substring"><a href="#method-substring" class="anchor"></a><code><span><span class="keyword">method</span> substring : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Pp/index.html b/doc/html/read-dwarf/Utils/Pp/index.html
index 00ed5bf3..50d84486 100644
--- a/doc/html/read-dwarf/Utils/Pp/index.html
+++ b/doc/html/read-dwarf/Utils/Pp/index.html
@@ -1,12 +1,52 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Pp (read-dwarf.Utils.Pp)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Pp</nav><h1>Module <code>Utils.Pp</code></h1><nav class="toc"><ul><li><a href="#rendering-documents">Rendering documents</a><ul><li><a href="#rendfmt">Render documents in format strings</a></li></ul></li><li><a href="#combinators">Combinators</a></li><li><a href="#special-printer">Special printer</a></li></ul></nav></header><aside><p>This module provide all pretty printing functionality. It's main goal is not directly handle the output but to handle how to layout complex data structure in a text format.</p><p>The main idea of this library is to separate the layout description phase from the part where you actually lay out the thing to pretty print. Thus the two stage of pretty printing is first to generate a <a href="index.html#type-document"><code>document</code></a> object describing the layout from the object to print and then render the document to the string using one of the printing</p></aside><div><div class="spec include"><div class="doc"><p>This is a wrapper around the <a href="http://cambium.inria.fr/~fpottier/pprint/doc/pprint/pprint/index.html"><code>pprint</code></a> library</p><details open="open"><summary><span class="def"><code><span class="keyword">include</span> PPrint</code></span></summary><dl><dt class="spec type" id="type-document"><a href="#type-document" class="anchor"></a><code><span class="keyword">type</span> document</code><code> = PPrintEngine.document</code></dt></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-char"><a href="#val-char" class="anchor"></a><code><span class="keyword">val</span> char : char <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-string"><a href="#val-string" class="anchor"></a><code><span class="keyword">val</span> string : string <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-substring"><a href="#val-substring" class="anchor"></a><code><span class="keyword">val</span> substring : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-fancystring"><a href="#val-fancystring" class="anchor"></a><code><span class="keyword">val</span> fancystring : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-fancysubstring"><a href="#val-fancysubstring" class="anchor"></a><code><span class="keyword">val</span> fancysubstring : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-utf8string"><a href="#val-utf8string" class="anchor"></a><code><span class="keyword">val</span> utf8string : string <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-utf8format"><a href="#val-utf8format" class="anchor"></a><code><span class="keyword">val</span> utf8format : <span><span>(<span class="type-var">'a</span>, unit, string, <a href="index.html#type-document">document</a>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-hardline"><a href="#val-hardline" class="anchor"></a><code><span class="keyword">val</span> hardline : <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-blank"><a href="#val-blank" class="anchor"></a><code><span class="keyword">val</span> blank : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-break"><a href="#val-break" class="anchor"></a><code><span class="keyword">val</span> break : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-(^^)"><a href="#val-(^^)" class="anchor"></a><code><span class="keyword">val</span> (^^) : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-nest"><a href="#val-nest" class="anchor"></a><code><span class="keyword">val</span> nest : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-group"><a href="#val-group" class="anchor"></a><code><span class="keyword">val</span> group : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-ifflat"><a href="#val-ifflat" class="anchor"></a><code><span class="keyword">val</span> ifflat : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-align"><a href="#val-align" class="anchor"></a><code><span class="keyword">val</span> align : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt></dl><dl><dt class="spec type" id="type-point"><a href="#type-point" class="anchor"></a><code><span class="keyword">type</span> point</code><code> = int * int</code></dt><dt class="spec type" id="type-range"><a href="#type-range" class="anchor"></a><code><span class="keyword">type</span> range</code><code> = <a href="index.html#type-point">point</a> * <a href="index.html#type-point">point</a></code></dt></dl><dl><dt class="spec value" id="val-range"><a href="#val-range" class="anchor"></a><code><span class="keyword">val</span> range : <span>(<a href="index.html#type-range">range</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt></dl><div class="spec module" id="module-ToChannel"><a href="#module-ToChannel" class="anchor"></a><code><span class="keyword">module</span> ToChannel = PPrintEngine.ToChannel</code></div><div class="spec module" id="module-ToBuffer"><a href="#module-ToBuffer" class="anchor"></a><code><span class="keyword">module</span> ToBuffer = PPrintEngine.ToBuffer</code></div><div class="spec module" id="module-ToFormatter"><a href="#module-ToFormatter" class="anchor"></a><code><span class="keyword">module</span> ToFormatter = PPrintEngine.ToFormatter</code></div><dl><dt class="spec type" id="type-requirement"><a href="#type-requirement" class="anchor"></a><code><span class="keyword">type</span> requirement</code><code> = int</code></dt></dl><dl><dt class="spec value" id="val-infinity"><a href="#val-infinity" class="anchor"></a><code><span class="keyword">val</span> infinity : <a href="index.html#type-requirement">requirement</a></code></dt></dl><div class="spec class-type" id="class-type-output"><a href="#class-type-output" class="anchor"></a><code><span class="keyword">class</span> <span class="keyword">type</span>  <a href="class-type-output/index.html">output</a> = <span class="keyword">object</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-state"><a href="#type-state" class="anchor"></a><code><span class="keyword">type</span> state</code><code> = PPrintEngine.state</code><code> = </code><code>{</code><table class="record"><tr id="type-state.width" class="anchored"><td class="def field"><a href="#type-state.width" class="anchor"></a><code>width : int;</code></td></tr><tr id="type-state.ribbon" class="anchored"><td class="def field"><a href="#type-state.ribbon" class="anchor"></a><code>ribbon : int;</code></td></tr><tr id="type-state.last_indent" class="anchored"><td class="def field"><a href="#type-state.last_indent" class="anchor"></a><code><span class="keyword">mutable</span> last_indent : int;</code></td></tr><tr id="type-state.line" class="anchored"><td class="def field"><a href="#type-state.line" class="anchor"></a><code><span class="keyword">mutable</span> line : int;</code></td></tr><tr id="type-state.column" class="anchored"><td class="def field"><a href="#type-state.column" class="anchor"></a><code><span class="keyword">mutable</span> column : int;</code></td></tr></table><code>}</code></dt></dl><div class="spec class-type" id="class-type-custom"><a href="#class-type-custom" class="anchor"></a><code><span class="keyword">class</span> <span class="keyword">type</span>  <a href="class-type-custom/index.html">custom</a> = <span class="keyword">object</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-custom"><a href="#val-custom" class="anchor"></a><code><span class="keyword">val</span> custom : <a href="class-type-custom/index.html">custom</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dt class="spec value" id="val-requirement"><a href="#val-requirement" class="anchor"></a><code><span class="keyword">val</span> requirement : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <a href="index.html#type-requirement">requirement</a></code></dt><dt class="spec value" id="val-pretty"><a href="#val-pretty" class="anchor"></a><code><span class="keyword">val</span> pretty : <a href="class-type-output/index.html">output</a> <span>&#45;&gt;</span> <a href="index.html#type-state">state</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-compact"><a href="#val-compact" class="anchor"></a><code><span class="keyword">val</span> compact : <a href="class-type-output/index.html">output</a> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-lparen"><a href="#val-lparen" class="anchor"></a><code><span class="keyword">val</span> lparen : PPrintEngine.document</code></dt><dt class="spec value" id="val-rparen"><a href="#val-rparen" class="anchor"></a><code><span class="keyword">val</span> rparen : PPrintEngine.document</code></dt><dt class="spec value" id="val-langle"><a href="#val-langle" class="anchor"></a><code><span class="keyword">val</span> langle : PPrintEngine.document</code></dt><dt class="spec value" id="val-rangle"><a href="#val-rangle" class="anchor"></a><code><span class="keyword">val</span> rangle : PPrintEngine.document</code></dt><dt class="spec value" id="val-lbrace"><a href="#val-lbrace" class="anchor"></a><code><span class="keyword">val</span> lbrace : PPrintEngine.document</code></dt><dt class="spec value" id="val-rbrace"><a href="#val-rbrace" class="anchor"></a><code><span class="keyword">val</span> rbrace : PPrintEngine.document</code></dt><dt class="spec value" id="val-lbracket"><a href="#val-lbracket" class="anchor"></a><code><span class="keyword">val</span> lbracket : PPrintEngine.document</code></dt><dt class="spec value" id="val-rbracket"><a href="#val-rbracket" class="anchor"></a><code><span class="keyword">val</span> rbracket : PPrintEngine.document</code></dt><dt class="spec value" id="val-squote"><a href="#val-squote" class="anchor"></a><code><span class="keyword">val</span> squote : PPrintEngine.document</code></dt><dt class="spec value" id="val-dquote"><a href="#val-dquote" class="anchor"></a><code><span class="keyword">val</span> dquote : PPrintEngine.document</code></dt><dt class="spec value" id="val-bquote"><a href="#val-bquote" class="anchor"></a><code><span class="keyword">val</span> bquote : PPrintEngine.document</code></dt><dt class="spec value" id="val-semi"><a href="#val-semi" class="anchor"></a><code><span class="keyword">val</span> semi : PPrintEngine.document</code></dt><dt class="spec value" id="val-colon"><a href="#val-colon" class="anchor"></a><code><span class="keyword">val</span> colon : PPrintEngine.document</code></dt><dt class="spec value" id="val-comma"><a href="#val-comma" class="anchor"></a><code><span class="keyword">val</span> comma : PPrintEngine.document</code></dt><dt class="spec value" id="val-space"><a href="#val-space" class="anchor"></a><code><span class="keyword">val</span> space : PPrintEngine.document</code></dt><dt class="spec value" id="val-dot"><a href="#val-dot" class="anchor"></a><code><span class="keyword">val</span> dot : PPrintEngine.document</code></dt><dt class="spec value" id="val-sharp"><a href="#val-sharp" class="anchor"></a><code><span class="keyword">val</span> sharp : PPrintEngine.document</code></dt><dt class="spec value" id="val-slash"><a href="#val-slash" class="anchor"></a><code><span class="keyword">val</span> slash : PPrintEngine.document</code></dt><dt class="spec value" id="val-backslash"><a href="#val-backslash" class="anchor"></a><code><span class="keyword">val</span> backslash : PPrintEngine.document</code></dt><dt class="spec value" id="val-equals"><a href="#val-equals" class="anchor"></a><code><span class="keyword">val</span> equals : PPrintEngine.document</code></dt><dt class="spec value" id="val-qmark"><a href="#val-qmark" class="anchor"></a><code><span class="keyword">val</span> qmark : PPrintEngine.document</code></dt><dt class="spec value" id="val-tilde"><a href="#val-tilde" class="anchor"></a><code><span class="keyword">val</span> tilde : PPrintEngine.document</code></dt><dt class="spec value" id="val-at"><a href="#val-at" class="anchor"></a><code><span class="keyword">val</span> at : PPrintEngine.document</code></dt><dt class="spec value" id="val-percent"><a href="#val-percent" class="anchor"></a><code><span class="keyword">val</span> percent : PPrintEngine.document</code></dt><dt class="spec value" id="val-dollar"><a href="#val-dollar" class="anchor"></a><code><span class="keyword">val</span> dollar : PPrintEngine.document</code></dt><dt class="spec value" id="val-caret"><a href="#val-caret" class="anchor"></a><code><span class="keyword">val</span> caret : PPrintEngine.document</code></dt><dt class="spec value" id="val-ampersand"><a href="#val-ampersand" class="anchor"></a><code><span class="keyword">val</span> ampersand : PPrintEngine.document</code></dt><dt class="spec value" id="val-star"><a href="#val-star" class="anchor"></a><code><span class="keyword">val</span> star : PPrintEngine.document</code></dt><dt class="spec value" id="val-plus"><a href="#val-plus" class="anchor"></a><code><span class="keyword">val</span> plus : PPrintEngine.document</code></dt><dt class="spec value" id="val-minus"><a href="#val-minus" class="anchor"></a><code><span class="keyword">val</span> minus : PPrintEngine.document</code></dt><dt class="spec value" id="val-underscore"><a href="#val-underscore" class="anchor"></a><code><span class="keyword">val</span> underscore : PPrintEngine.document</code></dt><dt class="spec value" id="val-bang"><a href="#val-bang" class="anchor"></a><code><span class="keyword">val</span> bang : PPrintEngine.document</code></dt><dt class="spec value" id="val-bar"><a href="#val-bar" class="anchor"></a><code><span class="keyword">val</span> bar : PPrintEngine.document</code></dt><dt class="spec value" id="val-precede"><a href="#val-precede" class="anchor"></a><code><span class="keyword">val</span> precede : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-terminate"><a href="#val-terminate" class="anchor"></a><code><span class="keyword">val</span> terminate : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-enclose"><a href="#val-enclose" class="anchor"></a><code><span class="keyword">val</span> enclose : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-squotes"><a href="#val-squotes" class="anchor"></a><code><span class="keyword">val</span> squotes : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-dquotes"><a href="#val-dquotes" class="anchor"></a><code><span class="keyword">val</span> dquotes : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-bquotes"><a href="#val-bquotes" class="anchor"></a><code><span class="keyword">val</span> bquotes : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-braces"><a href="#val-braces" class="anchor"></a><code><span class="keyword">val</span> braces : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-parens"><a href="#val-parens" class="anchor"></a><code><span class="keyword">val</span> parens : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-angles"><a href="#val-angles" class="anchor"></a><code><span class="keyword">val</span> angles : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-brackets"><a href="#val-brackets" class="anchor"></a><code><span class="keyword">val</span> brackets : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-twice"><a href="#val-twice" class="anchor"></a><code><span class="keyword">val</span> twice : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-repeat"><a href="#val-repeat" class="anchor"></a><code><span class="keyword">val</span> repeat : int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span class="keyword">val</span> concat : <span>PPrintEngine.document list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-separate"><a href="#val-separate" class="anchor"></a><code><span class="keyword">val</span> separate : PPrintEngine.document <span>&#45;&gt;</span> <span>PPrintEngine.document list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-concat_map"><a href="#val-concat_map" class="anchor"></a><code><span class="keyword">val</span> concat_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-separate_map"><a href="#val-separate_map" class="anchor"></a><code><span class="keyword">val</span> separate_map : PPrintEngine.document <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-separate2"><a href="#val-separate2" class="anchor"></a><code><span class="keyword">val</span> separate2 : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> <span>PPrintEngine.document list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-optional"><a href="#val-optional" class="anchor"></a><code><span class="keyword">val</span> optional : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-lines"><a href="#val-lines" class="anchor"></a><code><span class="keyword">val</span> lines : string <span>&#45;&gt;</span> <span>PPrintEngine.document list</span></code></dt><dt class="spec value" id="val-arbitrary_string"><a href="#val-arbitrary_string" class="anchor"></a><code><span class="keyword">val</span> arbitrary_string : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-words"><a href="#val-words" class="anchor"></a><code><span class="keyword">val</span> words : string <span>&#45;&gt;</span> <span>PPrintEngine.document list</span></code></dt><dt class="spec value" id="val-split"><a href="#val-split" class="anchor"></a><code><span class="keyword">val</span> split : <span>(char <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>PPrintEngine.document list</span></code></dt><dt class="spec value" id="val-flow"><a href="#val-flow" class="anchor"></a><code><span class="keyword">val</span> flow : PPrintEngine.document <span>&#45;&gt;</span> <span>PPrintEngine.document list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-flow_map"><a href="#val-flow_map" class="anchor"></a><code><span class="keyword">val</span> flow_map : PPrintEngine.document <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-url"><a href="#val-url" class="anchor"></a><code><span class="keyword">val</span> url : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-hang"><a href="#val-hang" class="anchor"></a><code><span class="keyword">val</span> hang : int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-prefix"><a href="#val-prefix" class="anchor"></a><code><span class="keyword">val</span> prefix : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-jump"><a href="#val-jump" class="anchor"></a><code><span class="keyword">val</span> jump : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-infix"><a href="#val-infix" class="anchor"></a><code><span class="keyword">val</span> infix : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-surround"><a href="#val-surround" class="anchor"></a><code><span class="keyword">val</span> surround : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-soft_surround"><a href="#val-soft_surround" class="anchor"></a><code><span class="keyword">val</span> soft_surround : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-surround_separate"><a href="#val-surround_separate" class="anchor"></a><code><span class="keyword">val</span> surround_separate : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> <span>PPrintEngine.document list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-surround_separate_map"><a href="#val-surround_separate_map" class="anchor"></a><code><span class="keyword">val</span> surround_separate_map : int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> PPrintEngine.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-(!^)"><a href="#val-(!^)" class="anchor"></a><code><span class="keyword">val</span> (!^) : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-(^/^)"><a href="#val-(^/^)" class="anchor"></a><code><span class="keyword">val</span> (^/^) : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dt class="spec value" id="val-(^//^)"><a href="#val-(^//^)" class="anchor"></a><code><span class="keyword">val</span> (^//^) : PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document <span>&#45;&gt;</span> PPrintEngine.document</code></dt></dl><div class="spec module" id="module-OCaml"><a href="#module-OCaml" class="anchor"></a><code><span class="keyword">module</span> OCaml = PPrintOCaml</code></div></details></div></div></div><section><header><h2 id="rendering-documents"><a href="#rendering-documents" class="anchor"></a>Rendering documents</h2><p>This section provide function to render documents in a text output.</p><p>However unless you know what you are doing, you may prefer using the <a href="../Logs/index.html"><code>Logs</code></a> module with the function of &quot;<a href="index.html#rendfmt"><span>Render documents in format strings</span></a>&quot;, instead of calling those function directly.</p></header><dl><dt class="spec value" id="val-fprint"><a href="#val-fprint" class="anchor"></a><code><span class="keyword">val</span> fprint : Stdlib.out_channel <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Render the document in a pretty manner on the provided <code>out_channel</code></p></dd></dl><dl><dt class="spec value" id="val-fprintln"><a href="#val-fprintln" class="anchor"></a><code><span class="keyword">val</span> fprintln : Stdlib.out_channel <span>&#45;&gt;</span> <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Render the document in a compact manner on the provided <code>out_channel</code></p></dd></dl><dl><dt class="spec value" id="val-print"><a href="#val-print" class="anchor"></a><code><span class="keyword">val</span> print : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Print the document on <code>stdout</code>. The general way of</p></dd></dl><dl><dt class="spec value" id="val-println"><a href="#val-println" class="anchor"></a><code><span class="keyword">val</span> println : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Print the document on <code>stdout</code>, then a endline, then flush</p></dd></dl><dl><dt class="spec value" id="val-eprintln"><a href="#val-eprintln" class="anchor"></a><code><span class="keyword">val</span> eprintln : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Print the document on <code>stderr</code>, then a endline, then flush</p></dd></dl><dl><dt class="spec value" id="val-sprintc"><a href="#val-sprintc" class="anchor"></a><code><span class="keyword">val</span> sprintc : <a href="index.html#module-ToBuffer">ToBuffer</a>.document <span>&#45;&gt;</span> string</code></dt><dd><p>Print the document in a string, in a compact manner</p></dd></dl><dl><dt class="spec value" id="val-sprint"><a href="#val-sprint" class="anchor"></a><code><span class="keyword">val</span> sprint : <a href="index.html#module-ToBuffer">ToBuffer</a>.document <span>&#45;&gt;</span> string</code></dt><dd><p>Print the document in a string, in a pretty manner</p></dd></dl><section><header><h3 id="rendfmt"><a href="#rendfmt" class="anchor"></a>Render documents in format strings</h3><p>This sub section provide functions to embed a <code>pprint</code> in a usual <code>printf</code>-like format string.</p><p>The general usage is to use the <code>%t</code> format and then appropriate mapping function. For example:</p><pre><code class="ml">Printf.printf &quot;Documents: %t&quot; Pp.(top printer object)</code></pre><p>This is lazy which means that if you use this in disabled debug messages, the object will not even be read. The only cost will be to allocate the closure on the minor GC.</p><p>Wheter to use <a href="index.html#val-top"><code>top</code></a> or <a href="index.html#val-tos"><code>tos</code></a> depends if the final output is an output stream or a plain string.</p></header><dl><dt class="spec value" id="val-top"><a href="#val-top" class="anchor"></a><code><span class="keyword">val</span> top : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> Stdlib.out_channel <span>&#45;&gt;</span> unit</code></dt><dd><p>Convert a document printer to a Printf format string via <code>%t</code> for function outputing on an <code>out_channel</code></p></dd></dl><dl><dt class="spec value" id="val-topi"><a href="#val-topi" class="anchor"></a><code><span class="keyword">val</span> topi : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> Stdlib.out_channel <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-top"><code>top</code></a> but add 4 space of indentation everywhere on the object. The general use is:</p><pre><code class="ml">Printf.printf &quot;Object:\n%t\n&quot; Pp.(topi printer object)</code></pre><p>and it will print:</p><pre>Object:
-    object line 1
-    object line 2</pre></dd></dl><dl><dt class="spec value" id="val-tos"><a href="#val-tos" class="anchor"></a><code><span class="keyword">val</span> tos : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#module-ToBuffer">ToBuffer</a>.document)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> string</code></dt><dd><p>Convert a document printer to a Printf format string via <code>%t</code> for function outputing in a string</p></dd></dl></section></section><section><header><h2 id="combinators"><a href="#combinators" class="anchor"></a>Combinators</h2><p>This section provide function to create documents from various object as well as combinators to generate documents from more complex objects.</p></header><dl><dt class="spec value" id="val-dprintf"><a href="#val-dprintf" class="anchor"></a><code><span class="keyword">val</span> dprintf : <span><span>(<span class="type-var">'a</span>, unit, string, PPrintEngine.document)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Printf like function that returns a document of the formatted string. In the end, it's just a string document, nothing more complex</p></dd></dl><dl><dt class="spec value" id="val-space"><a href="#val-space" class="anchor"></a><code><span class="keyword">val</span> space : <a href="index.html#type-document">document</a></code></dt><dd><p>A breakable space</p></dd></dl><dl><dt class="spec value" id="val-nbspace"><a href="#val-nbspace" class="anchor"></a><code><span class="keyword">val</span> nbspace : <a href="index.html#type-document">document</a></code></dt><dd><p>A non-breakable space (equivalent to <code>char ' '</code>)</p></dd></dl><dl><dt class="spec value" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span class="keyword">val</span> bool : bool <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Print a boolean as &quot;true&quot; or &quot;false&quot;</p></dd></dl><dl><dt class="spec value" id="val-int"><a href="#val-int" class="anchor"></a><code><span class="keyword">val</span> int : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an int in decimal</p></dd></dl><dl><dt class="spec value" id="val-hex"><a href="#val-hex" class="anchor"></a><code><span class="keyword">val</span> hex : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an int in hexadecimal as if it was unsigned</p></dd></dl><dl><dt class="spec value" id="val-shex"><a href="#val-shex" class="anchor"></a><code><span class="keyword">val</span> shex : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an int in hexadecimal with a sign: <code>-1</code> will be printed to <code>-0x1</code></p></dd></dl><dl><dt class="spec value" id="val-ptr"><a href="#val-ptr" class="anchor"></a><code><span class="keyword">val</span> ptr : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an int in hexadecimal with the <code>0x</code> prefix</p></dd></dl><dl><dt class="spec value" id="val-byte"><a href="#val-byte" class="anchor"></a><code><span class="keyword">val</span> byte : char <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print a byte as 2 hexadecimal digit</p></dd></dl><dl><dt class="spec value" id="val-hex16"><a href="#val-hex16" class="anchor"></a><code><span class="keyword">val</span> hex16 : int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an unsigned 16 bit integer as 4 hexadecimal digit</p></dd></dl><dl><dt class="spec value" id="val-hex32"><a href="#val-hex32" class="anchor"></a><code><span class="keyword">val</span> hex32 : int32 <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an unsigned 32 bit integer as 8 hexadecimal digit</p></dd></dl><dl><dt class="spec value" id="val-hex64"><a href="#val-hex64" class="anchor"></a><code><span class="keyword">val</span> hex64 : int64 <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print an unsigned 64 bit integer as 16 hexadecimal digit</p></dd></dl><dl><dt class="spec value" id="val-array"><a href="#val-array" class="anchor"></a><code><span class="keyword">val</span> array : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation</code></dt><dd><p>Print an array when provided with an element printer</p></dd></dl><dl><dt class="spec value" id="val-list"><a href="#val-list" class="anchor"></a><code><span class="keyword">val</span> list : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation</code></dt><dd><p>Print an list when provided with an element printer</p></dd></dl><dl><dt class="spec value" id="val-opt"><a href="#val-opt" class="anchor"></a><code><span class="keyword">val</span> opt : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation</code></dt><dd><p>Print an option when provided with an element printer</p></dd></dl><dl><dt class="spec value" id="val-pair"><a href="#val-pair" class="anchor"></a><code><span class="keyword">val</span> pair : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation</code></dt><dd><p>Print an pair when provided with both element printers</p></dd></dl><dl><dt class="spec value" id="val-tup3"><a href="#val-tup3" class="anchor"></a><code><span class="keyword">val</span> tup3 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'c</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <a href="index.html#module-OCaml">OCaml</a>.representation</code></dt><dd><p>Print an 3-sized tuple when provided with all three element printers</p></dd></dl><dl><dt class="spec value" id="val-qstring"><a href="#val-qstring" class="anchor"></a><code><span class="keyword">val</span> qstring : string <span>&#45;&gt;</span> PPrintEngine.document</code></dt><dd><p>Print a quoted string</p></dd></dl><dl><dt class="spec value" id="val-erase"><a href="#val-erase" class="anchor"></a><code><span class="keyword">val</span> erase : <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Ignore the input and print nothing</p></dd></dl><dl><dt class="spec value" id="val-mapping"><a href="#val-mapping" class="anchor"></a><code><span class="keyword">val</span> mapping : string <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-document">document</a> * <a href="index.html#type-document">document</a>)</span> list</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Prints a mapping with this style:</p><pre>name{
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Pp (read-dwarf.Utils.Pp)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Pp</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Pp</span></code></h1><p>This module provide all pretty printing functionality. It's main goal is not directly handle the output but to handle how to layout complex data structure in a text format.</p><p>The main idea of this library is to separate the layout description phase from the part where you actually lay out the thing to pretty print. Thus the two stage of pretty printing is first to generate a <a href="#type-document"><code>document</code></a> object describing the layout from the object to print and then render the document to the string using one of the printing</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#rendering-documents">Rendering documents</a><ul><li><a href="#rendfmt">Render documents in format strings</a></li></ul></li><li><a href="#combinators">Combinators</a></li><li><a href="#special-printer">Special printer</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-include"><div class="spec-doc"><p>This is a wrapper around the <a href="http://cambium.inria.fr/~fpottier/pprint/doc/pprint/pprint/index.html"><code>pprint</code></a> library</p></div><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">PPrint</span> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-document"><a href="#type-document" class="anchor"></a><code><span><span class="keyword">type</span> document</span><span> = <span class="xref-unresolved">PPrint</span>.document</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-char"><a href="#val-char" class="anchor"></a><code><span><span class="keyword">val</span> char : <span>char <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-string"><a href="#val-string" class="anchor"></a><code><span><span class="keyword">val</span> string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-substring"><a href="#val-substring" class="anchor"></a><code><span><span class="keyword">val</span> substring : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fancystring"><a href="#val-fancystring" class="anchor"></a><code><span><span class="keyword">val</span> fancystring : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fancysubstring"><a href="#val-fancysubstring" class="anchor"></a><code><span><span class="keyword">val</span> fancysubstring : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-utf8string"><a href="#val-utf8string" class="anchor"></a><code><span><span class="keyword">val</span> utf8string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-utf8format"><a href="#val-utf8format" class="anchor"></a><code><span><span class="keyword">val</span> utf8format : <span><span><span>(<span class="type-var">'a</span>, unit, string, <a href="#type-document">document</a>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hardline"><a href="#val-hardline" class="anchor"></a><code><span><span class="keyword">val</span> hardline : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blank"><a href="#val-blank" class="anchor"></a><code><span><span class="keyword">val</span> blank : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-break"><a href="#val-break" class="anchor"></a><code><span><span class="keyword">val</span> break : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(^^)"><a href="#val-(^^)" class="anchor"></a><code><span><span class="keyword">val</span> (^^) : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-group"><a href="#val-group" class="anchor"></a><code><span><span class="keyword">val</span> group : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ifflat"><a href="#val-ifflat" class="anchor"></a><code><span><span class="keyword">val</span> ifflat : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nest"><a href="#val-nest" class="anchor"></a><code><span><span class="keyword">val</span> nest : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-align"><a href="#val-align" class="anchor"></a><code><span><span class="keyword">val</span> align : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-point"><a href="#type-point" class="anchor"></a><code><span><span class="keyword">type</span> point</span><span> = int * int</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-range"><a href="#type-range" class="anchor"></a><code><span><span class="keyword">type</span> range</span><span> = <a href="#type-point">point</a> * <a href="#type-point">point</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-range"><a href="#val-range" class="anchor"></a><code><span><span class="keyword">val</span> range : <span><span>(<span><a href="#type-range">range</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-RENDERER"><a href="#module-type-RENDERER" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> RENDERER</span><span> = <span class="xref-unresolved">PPrint</span>.RENDERER</span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ToChannel"><a href="#module-ToChannel" class="anchor"></a><code><span><span class="keyword">module</span> ToChannel</span><span> = <span class="xref-unresolved">PPrint</span>.ToChannel</span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ToBuffer"><a href="#module-ToBuffer" class="anchor"></a><code><span><span class="keyword">module</span> ToBuffer</span><span> = <span class="xref-unresolved">PPrint</span>.ToBuffer</span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ToFormatter"><a href="#module-ToFormatter" class="anchor"></a><code><span><span class="keyword">module</span> ToFormatter</span><span> = <span class="xref-unresolved">PPrint</span>.ToFormatter</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-requirement"><a href="#type-requirement" class="anchor"></a><code><span><span class="keyword">type</span> requirement</span><span> = int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-infinity"><a href="#val-infinity" class="anchor"></a><code><span><span class="keyword">val</span> infinity : <a href="#type-requirement">requirement</a></span></code></div></div><div class="odoc-spec"><div class="spec class-type anchored" id="class-type-output"><a href="#class-type-output" class="anchor"></a><code><span><span class="keyword">class</span> <span class="keyword">type</span>  </span><span><a href="class-type-output/index.html">output</a></span><span> = <span class="keyword">object</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-state"><a href="#type-state" class="anchor"></a><code><span><span class="keyword">type</span> state</span><span> = <span class="xref-unresolved">PPrint</span>.state</span><span> = </span><span>{</span></code><ol><li id="type-state.width" class="def record field anchored"><a href="#type-state.width" class="anchor"></a><code><span>width : int;</span></code></li><li id="type-state.ribbon" class="def record field anchored"><a href="#type-state.ribbon" class="anchor"></a><code><span>ribbon : int;</span></code></li><li id="type-state.last_indent" class="def record field anchored"><a href="#type-state.last_indent" class="anchor"></a><code><span><span class="keyword">mutable</span> last_indent : int;</span></code></li><li id="type-state.line" class="def record field anchored"><a href="#type-state.line" class="anchor"></a><code><span><span class="keyword">mutable</span> line : int;</span></code></li><li id="type-state.column" class="def record field anchored"><a href="#type-state.column" class="anchor"></a><code><span><span class="keyword">mutable</span> column : int;</span></code></li></ol><code><span>}</span></code></div></div><div class="odoc-spec"><div class="spec class-type anchored" id="class-type-custom"><a href="#class-type-custom" class="anchor"></a><code><span><span class="keyword">class</span> <span class="keyword">type</span>  </span><span><a href="class-type-custom/index.html">custom</a></span><span> = <span class="keyword">object</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-custom"><a href="#val-custom" class="anchor"></a><code><span><span class="keyword">val</span> custom : <span><span class="xref-unresolved">custom</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-requirement"><a href="#val-requirement" class="anchor"></a><code><span><span class="keyword">val</span> requirement : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-requirement">requirement</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pretty"><a href="#val-pretty" class="anchor"></a><code><span><span class="keyword">val</span> pretty : <span><span class="xref-unresolved">output</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-state">state</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bool <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compact"><a href="#val-compact" class="anchor"></a><code><span><span class="keyword">val</span> compact : <span><span class="xref-unresolved">output</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lparen"><a href="#val-lparen" class="anchor"></a><code><span><span class="keyword">val</span> lparen : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rparen"><a href="#val-rparen" class="anchor"></a><code><span><span class="keyword">val</span> rparen : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-langle"><a href="#val-langle" class="anchor"></a><code><span><span class="keyword">val</span> langle : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rangle"><a href="#val-rangle" class="anchor"></a><code><span><span class="keyword">val</span> rangle : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lbrace"><a href="#val-lbrace" class="anchor"></a><code><span><span class="keyword">val</span> lbrace : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rbrace"><a href="#val-rbrace" class="anchor"></a><code><span><span class="keyword">val</span> rbrace : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lbracket"><a href="#val-lbracket" class="anchor"></a><code><span><span class="keyword">val</span> lbracket : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rbracket"><a href="#val-rbracket" class="anchor"></a><code><span><span class="keyword">val</span> rbracket : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-squote"><a href="#val-squote" class="anchor"></a><code><span><span class="keyword">val</span> squote : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dquote"><a href="#val-dquote" class="anchor"></a><code><span><span class="keyword">val</span> dquote : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bquote"><a href="#val-bquote" class="anchor"></a><code><span><span class="keyword">val</span> bquote : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-semi"><a href="#val-semi" class="anchor"></a><code><span><span class="keyword">val</span> semi : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-colon"><a href="#val-colon" class="anchor"></a><code><span><span class="keyword">val</span> colon : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-comma"><a href="#val-comma" class="anchor"></a><code><span><span class="keyword">val</span> comma : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dot"><a href="#val-dot" class="anchor"></a><code><span><span class="keyword">val</span> dot : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sharp"><a href="#val-sharp" class="anchor"></a><code><span><span class="keyword">val</span> sharp : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-slash"><a href="#val-slash" class="anchor"></a><code><span><span class="keyword">val</span> slash : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-backslash"><a href="#val-backslash" class="anchor"></a><code><span><span class="keyword">val</span> backslash : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equals"><a href="#val-equals" class="anchor"></a><code><span><span class="keyword">val</span> equals : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-qmark"><a href="#val-qmark" class="anchor"></a><code><span><span class="keyword">val</span> qmark : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tilde"><a href="#val-tilde" class="anchor"></a><code><span><span class="keyword">val</span> tilde : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at"><a href="#val-at" class="anchor"></a><code><span><span class="keyword">val</span> at : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-percent"><a href="#val-percent" class="anchor"></a><code><span><span class="keyword">val</span> percent : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dollar"><a href="#val-dollar" class="anchor"></a><code><span><span class="keyword">val</span> dollar : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-caret"><a href="#val-caret" class="anchor"></a><code><span><span class="keyword">val</span> caret : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ampersand"><a href="#val-ampersand" class="anchor"></a><code><span><span class="keyword">val</span> ampersand : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-star"><a href="#val-star" class="anchor"></a><code><span><span class="keyword">val</span> star : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-plus"><a href="#val-plus" class="anchor"></a><code><span><span class="keyword">val</span> plus : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-minus"><a href="#val-minus" class="anchor"></a><code><span><span class="keyword">val</span> minus : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-underscore"><a href="#val-underscore" class="anchor"></a><code><span><span class="keyword">val</span> underscore : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bang"><a href="#val-bang" class="anchor"></a><code><span><span class="keyword">val</span> bang : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bar"><a href="#val-bar" class="anchor"></a><code><span><span class="keyword">val</span> bar : <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-precede"><a href="#val-precede" class="anchor"></a><code><span><span class="keyword">val</span> precede : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-terminate"><a href="#val-terminate" class="anchor"></a><code><span><span class="keyword">val</span> terminate : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-enclose"><a href="#val-enclose" class="anchor"></a><code><span><span class="keyword">val</span> enclose : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-squotes"><a href="#val-squotes" class="anchor"></a><code><span><span class="keyword">val</span> squotes : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dquotes"><a href="#val-dquotes" class="anchor"></a><code><span><span class="keyword">val</span> dquotes : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bquotes"><a href="#val-bquotes" class="anchor"></a><code><span><span class="keyword">val</span> bquotes : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-braces"><a href="#val-braces" class="anchor"></a><code><span><span class="keyword">val</span> braces : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-parens"><a href="#val-parens" class="anchor"></a><code><span><span class="keyword">val</span> parens : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-angles"><a href="#val-angles" class="anchor"></a><code><span><span class="keyword">val</span> angles : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-brackets"><a href="#val-brackets" class="anchor"></a><code><span><span class="keyword">val</span> brackets : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-twice"><a href="#val-twice" class="anchor"></a><code><span><span class="keyword">val</span> twice : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-repeat"><a href="#val-repeat" class="anchor"></a><code><span><span class="keyword">val</span> repeat : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><span><a href="#type-document">document</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-separate"><a href="#val-separate" class="anchor"></a><code><span><span class="keyword">val</span> separate : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-document">document</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_map"><a href="#val-concat_map" class="anchor"></a><code><span><span class="keyword">val</span> concat_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-separate_map"><a href="#val-separate_map" class="anchor"></a><code><span><span class="keyword">val</span> separate_map : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-separate2"><a href="#val-separate2" class="anchor"></a><code><span><span class="keyword">val</span> separate2 : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-document">document</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-optional"><a href="#val-optional" class="anchor"></a><code><span><span class="keyword">val</span> optional : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lines"><a href="#val-lines" class="anchor"></a><code><span><span class="keyword">val</span> lines : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-arbitrary_string"><a href="#val-arbitrary_string" class="anchor"></a><code><span><span class="keyword">val</span> arbitrary_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-words"><a href="#val-words" class="anchor"></a><code><span><span class="keyword">val</span> words : <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flow"><a href="#val-flow" class="anchor"></a><code><span><span class="keyword">val</span> flow : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><span><a href="#type-document">document</a> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flow_map"><a href="#val-flow_map" class="anchor"></a><code><span><span class="keyword">val</span> flow_map : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-url"><a href="#val-url" class="anchor"></a><code><span><span class="keyword">val</span> url : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hang"><a href="#val-hang" class="anchor"></a><code><span><span class="keyword">val</span> hang : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prefix"><a href="#val-prefix" class="anchor"></a><code><span><span class="keyword">val</span> prefix : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-jump"><a href="#val-jump" class="anchor"></a><code><span><span class="keyword">val</span> jump : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-infix"><a href="#val-infix" class="anchor"></a><code><span><span class="keyword">val</span> infix : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-surround"><a href="#val-surround" class="anchor"></a><code><span><span class="keyword">val</span> surround : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-soft_surround"><a href="#val-soft_surround" class="anchor"></a><code><span><span class="keyword">val</span> soft_surround : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-surround_separate"><a href="#val-surround_separate" class="anchor"></a><code><span><span class="keyword">val</span> surround_separate : 
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><a href="#type-document">document</a> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-surround_separate_map"><a href="#val-surround_separate_map" class="anchor"></a><code><span><span class="keyword">val</span> surround_separate_map : 
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span>int <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(!^)"><a href="#val-(!^)" class="anchor"></a><code><span><span class="keyword">val</span> (!^) : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(^/^)"><a href="#val-(^/^)" class="anchor"></a><code><span><span class="keyword">val</span> (^/^) : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(^//^)"><a href="#val-(^//^)" class="anchor"></a><code><span><span class="keyword">val</span> (^//^) : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-OCaml"><a href="#module-OCaml" class="anchor"></a><code><span><span class="keyword">module</span> OCaml</span><span> = <span class="xref-unresolved">PPrint</span>.OCaml</span></code></div></div></details></div><h2 id="rendering-documents"><a href="#rendering-documents" class="anchor"></a>Rendering documents</h2><p>This section provide function to render documents in a text output.</p><p>However unless you know what you are doing, you may prefer using the <a href="../Logs/index.html"><code>Logs</code></a> module with the function of &quot;<a href="#rendfmt" title="rendfmt">Render documents in format strings</a>&quot;, instead of calling those function directly.</p><div class="odoc-spec"><div class="spec value anchored" id="val-fprint"><a href="#val-fprint" class="anchor"></a><code><span><span class="keyword">val</span> fprint : <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Render the document in a pretty manner on the provided <code>out_channel</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fprintln"><a href="#val-fprintln" class="anchor"></a><code><span><span class="keyword">val</span> fprintln : <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Render the document in a compact manner on the provided <code>out_channel</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-print"><a href="#val-print" class="anchor"></a><code><span><span class="keyword">val</span> print : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Print the document on <code>stdout</code>. The general way of</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-println"><a href="#val-println" class="anchor"></a><code><span><span class="keyword">val</span> println : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Print the document on <code>stdout</code>, then a endline, then flush</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-eprintln"><a href="#val-eprintln" class="anchor"></a><code><span><span class="keyword">val</span> eprintln : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Print the document on <code>stderr</code>, then a endline, then flush</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sprintc"><a href="#val-sprintc" class="anchor"></a><code><span><span class="keyword">val</span> sprintc : <span><span class="xref-unresolved">ToBuffer</span>.document <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Print the document in a string, in a compact manner</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sprint"><a href="#val-sprint" class="anchor"></a><code><span><span class="keyword">val</span> sprint : <span><span class="xref-unresolved">ToBuffer</span>.document <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Print the document in a string, in a pretty manner</p></div></div><h3 id="rendfmt"><a href="#rendfmt" class="anchor"></a>Render documents in format strings</h3><p>This sub section provide functions to embed a <code>pprint</code> in a usual <code>printf</code>-like format string.</p><p>The general usage is to use the <code>%t</code> format and then appropriate mapping function. For example:</p><pre class="language-ocaml"><code>Printf.printf &quot;Documents: %t&quot; Pp.(top printer object)</code></pre><p>This is lazy which means that if you use this in disabled debug messages, the object will not even be read. The only cost will be to allocate the closure on the minor GC.</p><p>Wheter to use <a href="#val-top"><code>top</code></a> or <a href="#val-tos"><code>tos</code></a> depends if the final output is an output stream or a plain string.</p><div class="odoc-spec"><div class="spec value anchored" id="val-top"><a href="#val-top" class="anchor"></a><code><span><span class="keyword">val</span> top : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Convert a document printer to a Printf format string via <code>%t</code> for function outputing on an <code>out_channel</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-topi"><a href="#val-topi" class="anchor"></a><code><span><span class="keyword">val</span> topi : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Stdlib</span>.out_channel <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-top"><code>top</code></a> but add 4 space of indentation everywhere on the object. The general use is:</p><pre class="language-ocaml"><code>Printf.printf &quot;Object:\n%t\n&quot; Pp.(topi printer object)</code></pre><p>and it will print:</p><pre>Object:
+object line 1
+object line 2</pre></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tos"><a href="#val-tos" class="anchor"></a><code><span><span class="keyword">val</span> tos : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">ToBuffer</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Convert a document printer to a Printf format string via <code>%t</code> for function outputing in a string</p></div></div><h2 id="combinators"><a href="#combinators" class="anchor"></a>Combinators</h2><p>This section provide function to create documents from various object as well as combinators to generate documents from more complex objects.</p><div class="odoc-spec"><div class="spec value anchored" id="val-dprintf"><a href="#val-dprintf" class="anchor"></a><code><span><span class="keyword">val</span> dprintf : <span><span><span>(<span class="type-var">'a</span>, unit, string, <a href="#type-document">document</a>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Printf like function that returns a document of the formatted string. In the end, it's just a string document, nothing more complex</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-space"><a href="#val-space" class="anchor"></a><code><span><span class="keyword">val</span> space : <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>A breakable space</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nbspace"><a href="#val-nbspace" class="anchor"></a><code><span><span class="keyword">val</span> nbspace : <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>A non-breakable space (equivalent to <code>char ' '</code>)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bool"><a href="#val-bool" class="anchor"></a><code><span><span class="keyword">val</span> bool : <span>bool <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print a boolean as &quot;true&quot; or &quot;false&quot;</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-int"><a href="#val-int" class="anchor"></a><code><span><span class="keyword">val</span> int : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an int in decimal</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex"><a href="#val-hex" class="anchor"></a><code><span><span class="keyword">val</span> hex : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an int in hexadecimal as if it was unsigned</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shex"><a href="#val-shex" class="anchor"></a><code><span><span class="keyword">val</span> shex : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an int in hexadecimal with a sign: <code>-1</code> will be printed to <code>-0x1</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ptr"><a href="#val-ptr" class="anchor"></a><code><span><span class="keyword">val</span> ptr : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an int in hexadecimal with the <code>0x</code> prefix</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-byte"><a href="#val-byte" class="anchor"></a><code><span><span class="keyword">val</span> byte : <span>char <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print a byte as 2 hexadecimal digit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex16"><a href="#val-hex16" class="anchor"></a><code><span><span class="keyword">val</span> hex16 : <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an unsigned 16 bit integer as 4 hexadecimal digit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex32"><a href="#val-hex32" class="anchor"></a><code><span><span class="keyword">val</span> hex32 : <span>int32 <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an unsigned 32 bit integer as 8 hexadecimal digit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hex64"><a href="#val-hex64" class="anchor"></a><code><span><span class="keyword">val</span> hex64 : <span>int64 <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print an unsigned 64 bit integer as 16 hexadecimal digit</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-array"><a href="#val-array" class="anchor"></a><code><span><span class="keyword">val</span> array : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Print an array when provided with an element printer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-list"><a href="#val-list" class="anchor"></a><code><span><span class="keyword">val</span> list : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Print an list when provided with an element printer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-opt"><a href="#val-opt" class="anchor"></a><code><span><span class="keyword">val</span> opt : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Print an option when provided with an element printer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pair"><a href="#val-pair" class="anchor"></a><code><span><span class="keyword">val</span> pair : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Print an pair when provided with both element printers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tup3"><a href="#val-tup3" class="anchor"></a><code><span><span class="keyword">val</span> tup3 : 
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'c</span> <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">PPrint</span>.document)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span> * <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span class="xref-unresolved">PPrint</span>.document</span></code></div><div class="spec-doc"><p>Print an 3-sized tuple when provided with all three element printers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-qstring"><a href="#val-qstring" class="anchor"></a><code><span><span class="keyword">val</span> qstring : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print a quoted string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-erase"><a href="#val-erase" class="anchor"></a><code><span><span class="keyword">val</span> erase : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Ignore the input and print nothing</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapping"><a href="#val-mapping" class="anchor"></a><code><span><span class="keyword">val</span> mapping : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span><span>(<a href="#type-document">document</a> * <a href="#type-document">document</a>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Prints a mapping with this style:</p><pre>name{
     key -&gt; value;
     key -&gt; value;
     key -&gt; value;
-}</pre></dd></dl><dl><dt class="spec value" id="val-hashtbl"><a href="#val-hashtbl" class="anchor"></a><code><span class="keyword">val</span> hashtbl : <span>?&#8288;name:string</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> Stdlib.Hashtbl.t</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print a Hashtbl using <a href="index.html#val-mapping"><code>mapping</code></a></p></dd></dl><dl><dt class="spec value" id="val-hashtbl_sorted"><a href="#val-hashtbl_sorted" class="anchor"></a><code><span class="keyword">val</span> hashtbl_sorted : <span>compare:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span></span> <span>&#45;&gt;</span> <span>?&#8288;name:string</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'b</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> Stdlib.Hashtbl.t</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print a sorted Hashtbl using <a href="index.html#val-mapping"><code>mapping</code></a></p></dd></dl><dl><dt class="spec value" id="val-record"><a href="#val-record" class="anchor"></a><code><span class="keyword">val</span> record : <a href="index.html#module-OCaml">OCaml</a>.type_name <span>&#45;&gt;</span> <span><span>(<a href="index.html#module-OCaml">OCaml</a>.record_field * <a href="index.html#module-OCaml">OCaml</a>.representation)</span> list</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Print a record in the format</p><pre>name{
+}</pre></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hashtbl"><a href="#val-hashtbl" class="anchor"></a><code><span><span class="keyword">val</span> hashtbl : 
+  <span><span class="optlabel">?name</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print a Hashtbl using <a href="#val-mapping"><code>mapping</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hashtbl_sorted"><a href="#val-hashtbl_sorted" class="anchor"></a><code><span><span class="keyword">val</span> hashtbl_sorted : 
+  <span><span class="label">compare</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?name</span>:string <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.Hashtbl.t</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print a sorted Hashtbl using <a href="#val-mapping"><code>mapping</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-record"><a href="#val-record" class="anchor"></a><code><span><span class="keyword">val</span> record : 
+  <span><span class="xref-unresolved">OCaml</span>.type_name <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="xref-unresolved">OCaml</span>.record_field * <span class="xref-unresolved">PPrint</span>.document)</span> list</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Print a record in the format</p><pre>name{
     field = value;
     field = value;
     field = value;
-}</pre></dd></dl><dl><dt class="spec value" id="val-separate_mapi"><a href="#val-separate_mapi" class="anchor"></a><code><span class="keyword">val</span> separate_mapi : <a href="index.html#type-document">document</a> <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Like <a href="http://cambium.inria.fr/~fpottier/pprint/doc/pprint/pprint/index.html#val-separate_map"><code>separate_map</code></a> but with the index</p></dd></dl><dl><dt class="spec value" id="val-concat_array_map"><a href="#val-concat_array_map" class="anchor"></a><code><span class="keyword">val</span> concat_array_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Concatenate the documents produced by the function over the array</p></dd></dl><dl><dt class="spec value" id="val-concat_array_mapi"><a href="#val-concat_array_mapi" class="anchor"></a><code><span class="keyword">val</span> concat_array_mapi : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Concatenate the document produced by the function on the array. The function also gets the index of the element</p></dd></dl></section><section><header><h2 id="special-printer"><a href="#special-printer" class="anchor"></a>Special printer</h2></header><dl><dt class="spec value" id="val-status"><a href="#val-status" class="anchor"></a><code><span class="keyword">val</span> status : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-document">document</a>)</span> <span>&#45;&gt;</span> Unix.process_status <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Prints a <code>Unix.process_status</code> with an integer printer</p></dd></dl><dl><dt class="spec value" id="val-statusi"><a href="#val-statusi" class="anchor"></a><code><span class="keyword">val</span> statusi : Unix.process_status <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Prints a <code>Unix.process_status</code> with decimal integers</p></dd></dl><dl><dt class="spec value" id="val-statush"><a href="#val-statush" class="anchor"></a><code><span class="keyword">val</span> statush : Unix.process_status <span>&#45;&gt;</span> <a href="index.html#type-document">document</a></code></dt><dd><p>Prints a <code>Unix.process_status</code> with hexadecimal integers</p></dd></dl></section></div></body></html>
\ No newline at end of file
+}</pre></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-separate_mapi"><a href="#val-separate_mapi" class="anchor"></a><code><span><span class="keyword">val</span> separate_mapi : <span><a href="#type-document">document</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Like <a href="http://cambium.inria.fr/~fpottier/pprint/doc/pprint/pprint/index.html#val-separate_map"><code>separate_map</code></a> but with the index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_array_map"><a href="#val-concat_array_map" class="anchor"></a><code><span><span class="keyword">val</span> concat_array_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Concatenate the documents produced by the function over the array</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_array_mapi"><a href="#val-concat_array_mapi" class="anchor"></a><code><span><span class="keyword">val</span> concat_array_mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Concatenate the document produced by the function on the array. The function also gets the index of the element</p></div></div><h2 id="special-printer"><a href="#special-printer" class="anchor"></a>Special printer</h2><div class="odoc-spec"><div class="spec value anchored" id="val-status"><a href="#val-status" class="anchor"></a><code><span><span class="keyword">val</span> status : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="xref-unresolved">Unix</span>.process_status <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Prints a <code>Unix.process_status</code> with an integer printer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-statusi"><a href="#val-statusi" class="anchor"></a><code><span><span class="keyword">val</span> statusi : <span><span class="xref-unresolved">Unix</span>.process_status <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Prints a <code>Unix.process_status</code> with decimal integers</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-statush"><a href="#val-statush" class="anchor"></a><code><span><span class="keyword">val</span> statush : <span><span class="xref-unresolved">Unix</span>.process_status <span class="arrow">&#45;&gt;</span></span> <a href="#type-document">document</a></span></code></div><div class="spec-doc"><p>Prints a <code>Unix.process_status</code> with hexadecimal integers</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Protect/index.html b/doc/html/read-dwarf/Utils/Protect/index.html
index 476dab69..4509dd5a 100644
--- a/doc/html/read-dwarf/Utils/Protect/index.html
+++ b/doc/html/read-dwarf/Utils/Protect/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Protect (read-dwarf.Utils.Protect)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Protect</nav><h1>Module <code>Utils.Protect</code></h1></header><aside><p>This module provide try-with-finally kind of exception handling.</p><p>It provides a new kind of <a href="index.html#val-protect"><code>protect</code></a> function.</p><p>TODO: Think if this behavior is really useful compared to the standard <code>protect</code></p></aside><dl><dt class="spec exception" id="exception-Protect_both"><a href="#exception-Protect_both" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Protect_both</span> <span class="keyword">of</span> exn * exn</code></dt><dd><p>This exception it thrown when both function and protector have thrown</p></dd></dl><dl><dt class="spec value" id="val-protect"><a href="#val-protect" class="anchor"></a><code><span class="keyword">val</span> protect : <span>(unit <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span>(unit <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p><code>protect f p</code> runs f then p even if f throws.</p><p>If one of <code>f</code> or <code>p</code> throw, then that exception is transmitted as is If both throw, the pair of exceptions is encapsulated in <a href="index.html#exception-Protect_both"><code>Protect_both</code></a> and thrown.</p><p>This behavior is slightly different from the standard <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html#VALprotect"><code>protect</code></a>.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Protect (read-dwarf.Utils.Protect)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Protect</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Protect</span></code></h1><p>This module provide try-with-finally kind of exception handling.</p><p>It provides a new kind of <a href="#val-protect"><code>protect</code></a> function.</p><p>TODO: Think if this behavior is really useful compared to the standard <code>protect</code></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec exception anchored" id="exception-Protect_both"><a href="#exception-Protect_both" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Protect_both</span> <span class="keyword">of</span> exn * exn</span></code></div><div class="spec-doc"><p>This exception it thrown when both function and protector have thrown</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-protect"><a href="#val-protect" class="anchor"></a><code><span><span class="keyword">val</span> protect : <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p><code>protect f p</code> runs f then p even if f throws.</p><p>If one of <code>f</code> or <code>p</code> throw, then that exception is transmitted as is If both throw, the pair of exceptions is encapsulated in <a href="#exception-Protect_both"><code>Protect_both</code></a> and thrown.</p><p>This behavior is slightly different from the standard <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html#VALprotect"><code>protect</code></a>.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Raise/index.html b/doc/html/read-dwarf/Utils/Raise/index.html
index b5b58737..852c024f 100644
--- a/doc/html/read-dwarf/Utils/Raise/index.html
+++ b/doc/html/read-dwarf/Utils/Raise/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Raise (read-dwarf.Utils.Raise)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Raise</nav><h1>Module <code>Utils.Raise</code></h1></header><aside><p>This module provide convenience facilities to raise exception or other exception management</p></aside><dl><dt class="spec value" id="val-inv_arg"><a href="#val-inv_arg" class="anchor"></a><code><span class="keyword">val</span> inv_arg : <span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Printf like funtion that throws an <code>Invalid_Argument</code> with the formated string</p></dd></dl><dl><dt class="spec value" id="val-fail"><a href="#val-fail" class="anchor"></a><code><span class="keyword">val</span> fail : <span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> Stdlib.format4</span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Printf like funtion that throws a <code>Failure</code> with the formated string</p></dd></dl><dl><dt class="spec value" id="val-again"><a href="#val-again" class="anchor"></a><code><span class="keyword">val</span> again : exn <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Raise again an exception without losing the backtrace.</p></dd></dl><dl><dt class="spec exception" id="exception-Todo"><a href="#exception-Todo" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Todo</span></code></dt></dl><dl><dt class="spec value" id="val-todo"><a href="#val-todo" class="anchor"></a><code><span class="keyword">val</span> todo : unit <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Put that in unfinished places of the code that need to be completed</p></dd></dl><dl><dt class="spec exception" id="exception-Unreachable"><a href="#exception-Unreachable" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Unreachable</span></code></dt></dl><dl><dt class="spec value" id="val-unreachable"><a href="#val-unreachable" class="anchor"></a><code><span class="keyword">val</span> unreachable : unit <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Put that in-place of dead code that is required by the typer</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Raise (read-dwarf.Utils.Raise)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Raise</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Raise</span></code></h1><p>This module provide convenience facilities to raise exception or other exception management</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-inv_arg"><a href="#val-inv_arg" class="anchor"></a><code><span><span class="keyword">val</span> inv_arg : <span><span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Printf like funtion that throws an <code>Invalid_Argument</code> with the formated string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fail"><a href="#val-fail" class="anchor"></a><code><span><span class="keyword">val</span> fail : <span><span><span>(<span class="type-var">'a</span>, unit, string, <span class="type-var">'b</span>)</span> <span class="xref-unresolved">Stdlib</span>.format4</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Printf like funtion that throws a <code>Failure</code> with the formated string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-again"><a href="#val-again" class="anchor"></a><code><span><span class="keyword">val</span> again : <span>exn <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Raise again an exception without losing the backtrace.</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Todo"><a href="#exception-Todo" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Todo</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-todo"><a href="#val-todo" class="anchor"></a><code><span><span class="keyword">val</span> todo : <span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Put that in unfinished places of the code that need to be completed</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Unreachable"><a href="#exception-Unreachable" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Unreachable</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unreachable"><a href="#val-unreachable" class="anchor"></a><code><span><span class="keyword">val</span> unreachable : <span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Put that in-place of dead code that is required by the typer</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/IMap/index.html b/doc/html/read-dwarf/Utils/RngMap/IMap/index.html
index cea35fce..176ccaa1 100644
--- a/doc/html/read-dwarf/Utils/RngMap/IMap/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/IMap/index.html
@@ -1,2 +1,6 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IMap (read-dwarf.Utils.RngMap.IMap)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; IMap</nav><h1>Module <code>RngMap.IMap</code></h1><p>An integer map: <code>Map.Make(Int)</code></p></header><dl><dt class="spec type" id="type-key"><a href="#type-key" class="anchor"></a><code><span class="keyword">type</span> key</code><code> = Stdlib.Int.t</code></dt><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = <span><span class="type-var">'a</span> Stdlib__map.Make(Stdlib.Int).t</span></code></dt></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span class="keyword">val</span> is_empty : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-update"><a href="#val-update" class="anchor"></a><code><span class="keyword">val</span> update : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span>(<span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-singleton"><a href="#val-singleton" class="anchor"></a><code><span class="keyword">val</span> singleton : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span class="keyword">val</span> remove : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span class="keyword">val</span> merge : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-union"><a href="#val-union" class="anchor"></a><code><span class="keyword">val</span> union : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> int)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span class="keyword">val</span> fold : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span class="keyword">val</span> filter : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-partition"><a href="#val-partition" class="anchor"></a><code><span class="keyword">val</span> partition : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> * <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-cardinal"><a href="#val-cardinal" class="anchor"></a><code><span class="keyword">val</span> cardinal : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> list</span></code></dt><dt class="spec value" id="val-min_binding"><a href="#val-min_binding" class="anchor"></a><code><span class="keyword">val</span> min_binding : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> * <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-min_binding_opt"><a href="#val-min_binding_opt" class="anchor"></a><code><span class="keyword">val</span> min_binding_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></code></dt><dt class="spec value" id="val-max_binding"><a href="#val-max_binding" class="anchor"></a><code><span class="keyword">val</span> max_binding : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> * <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-max_binding_opt"><a href="#val-max_binding_opt" class="anchor"></a><code><span class="keyword">val</span> max_binding_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></code></dt><dt class="spec value" id="val-choose"><a href="#val-choose" class="anchor"></a><code><span class="keyword">val</span> choose : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> * <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-choose_opt"><a href="#val-choose_opt" class="anchor"></a><code><span class="keyword">val</span> choose_opt : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></code></dt><dt class="spec value" id="val-split"><a href="#val-split" class="anchor"></a><code><span class="keyword">val</span> split : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> * <span><span class="type-var">'a</span> option</span> * <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-find"><a href="#val-find" class="anchor"></a><code><span class="keyword">val</span> find : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span class="keyword">val</span> find_opt : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dt class="spec value" id="val-find_first"><a href="#val-find_first" class="anchor"></a><code><span class="keyword">val</span> find_first : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> * <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_first_opt"><a href="#val-find_first_opt" class="anchor"></a><code><span class="keyword">val</span> find_first_opt : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></code></dt><dt class="spec value" id="val-find_last"><a href="#val-find_last" class="anchor"></a><code><span class="keyword">val</span> find_last : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="index.html#type-key">key</a> * <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-find_last_opt"><a href="#val-find_last_opt" class="anchor"></a><code><span class="keyword">val</span> find_last_opt : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(<a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seq_from"><a href="#val-to_seq_from" class="anchor"></a><code><span class="keyword">val</span> to_seq_from : <a href="index.html#type-key">key</a> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span class="keyword">val</span> add_seq : <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span><span>(<a href="index.html#type-key">key</a> * <span class="type-var">'a</span>)</span> Stdlib.Seq.t</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>IMap (read-dwarf.Utils.RngMap.IMap)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; IMap</nav><header class="odoc-preamble"><h1>Module <code><span>RngMap.IMap</span></code></h1><p>An integer map: <code>Map.Make(Int)</code></p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-key"><a href="#type-key" class="anchor"></a><code><span><span class="keyword">type</span> key</span><span> = <span class="xref-unresolved">Stdlib</span>.Int.t</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib__Map</span>.Make(<span class="xref-unresolved">Stdlib</span>.Int).t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_to_list"><a href="#val-add_to_list" class="anchor"></a><code><span><span class="keyword">val</span> add_to_list : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> list</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-singleton"><a href="#val-singleton" class="anchor"></a><code><span><span class="keyword">val</span> singleton : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove"><a href="#val-remove" class="anchor"></a><code><span><span class="keyword">val</span> remove : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-merge"><a href="#val-merge" class="anchor"></a><code><span><span class="keyword">val</span> merge : 
+  <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> option</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-union"><a href="#val-union" class="anchor"></a><code><span><span class="keyword">val</span> union : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cardinal"><a href="#val-cardinal" class="anchor"></a><code><span><span class="keyword">val</span> cardinal : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min_binding"><a href="#val-min_binding" class="anchor"></a><code><span><span class="keyword">val</span> min_binding : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-key">key</a> * <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min_binding_opt"><a href="#val-min_binding_opt" class="anchor"></a><code><span><span class="keyword">val</span> min_binding_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_binding"><a href="#val-max_binding" class="anchor"></a><code><span><span class="keyword">val</span> max_binding : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-key">key</a> * <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_binding_opt"><a href="#val-max_binding_opt" class="anchor"></a><code><span><span class="keyword">val</span> max_binding_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-choose"><a href="#val-choose" class="anchor"></a><code><span><span class="keyword">val</span> choose : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-key">key</a> * <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-choose_opt"><a href="#val-choose_opt" class="anchor"></a><code><span><span class="keyword">val</span> choose_opt : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_opt"><a href="#val-find_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_opt : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_first"><a href="#val-find_first" class="anchor"></a><code><span><span class="keyword">val</span> find_first : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-key">key</a> * <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_first_opt"><a href="#val-find_first_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_first_opt : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_last"><a href="#val-find_last" class="anchor"></a><code><span><span class="keyword">val</span> find_last : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-key">key</a> * <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_last_opt"><a href="#val-find_last_opt" class="anchor"></a><code><span><span class="keyword">val</span> find_last_opt : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span><span class="keyword">val</span> filter : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span><span class="keyword">val</span> filter_map : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition"><a href="#val-partition" class="anchor"></a><code><span><span class="keyword">val</span> partition : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'a</span> option</span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_list"><a href="#val-of_list" class="anchor"></a><code><span><span class="keyword">val</span> of_list : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> list</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_rev_seq"><a href="#val-to_rev_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_rev_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_from"><a href="#val-to_seq_from" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_from : <span><a href="#type-key">key</a> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_seq"><a href="#val-add_seq" class="anchor"></a><code><span><span class="keyword">val</span> add_seq : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span><span>(<a href="#type-key">key</a> * <span class="type-var">'a</span>)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/Make/argument-1-Obj/index.html b/doc/html/read-dwarf/Utils/RngMap/Make/argument-1-Obj/index.html
index 62bdc02e..02072360 100644
--- a/doc/html/read-dwarf/Utils/RngMap/Make/argument-1-Obj/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/Make/argument-1-Obj/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Obj (read-dwarf.Utils.RngMap.Make.1-Obj)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">RngMap</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 1-Obj</nav><h1>Parameter <code>Make.1-Obj</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type to be indexed by starting addresses, must have a length</p></dd></dl><dl><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>The type of range end</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Obj (read-dwarf.Utils.RngMap.Make.Obj)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">RngMap</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Obj</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Obj</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type to be indexed by starting addresses, must have a length</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>The type of range end</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/Make/index.html b/doc/html/read-dwarf/Utils/RngMap/Make/index.html
index 18a830f2..b4fbf802 100644
--- a/doc/html/read-dwarf/Utils/RngMap/Make/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/Make/index.html
@@ -1,6 +1,11 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Utils.RngMap.Make)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; Make</nav><h1>Module <code>RngMap.Make</code></h1><p>How to make a <code>RngMap</code> from a <a href="../module-type-LenObject/index.html"><code>LenObject</code></a></p></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Obj/index.html">Obj</a> : <a href="../index.html#module-type-LenObject">LenObject</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span class="keyword">type</span> obj</code><code> = <a href="argument-1-Obj/index.html#type-t">Obj.t</a></code></dt><dd><p>The type of the contained object</p></dd></dl><dl><dt class="spec type" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span class="keyword">type</span> obj_off</code><code> = <a href="index.html#type-obj">obj</a> * int</code></dt><dd><p>The type of an object with an offset</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of the map from address ranges to <a href="index.html#type-obj"><code>obj</code></a></p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>An empty <code>RngMap</code></p></dd></dl><dl><dt class="spec value" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span class="keyword">val</span> is_in : <span>objaddr:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Test if an address is inside the object at address <code>objaddr</code></p></dd></dl><dl><dt class="spec value" id="val-at"><a href="#val-at" class="anchor"></a><code><span class="keyword">val</span> at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a></code></dt><dd><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span class="keyword">val</span> at_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj">obj</a> option</span></code></dt><dd><p>Get the object containing the address. <code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span class="keyword">val</span> at_off : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object</p><pre><code class="ml">at_off map addr = (obj, off) </code></pre><p>means:</p><pre>         |                      |           |         |
-       map 0                 obj start    point    obj end
-         |&lt;--------------addr--------------&gt;|
-                                |&lt;---off---&gt;|
-                                |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span class="keyword">val</span> at_off_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj_off">obj_off</a> option</span></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object. See <a href="index.html#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-update"><a href="#val-update" class="anchor"></a><code><span class="keyword">val</span> update : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></dd></dl><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span class="keyword">val</span> clear_at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear the object containing the address if any</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="index.html#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="index.html#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></dd></dl><dl><dt class="spec value" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span class="keyword">val</span> clear_crop : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span>crop:<span>(<span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></dd></dl><dl><dt class="spec value" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span class="keyword">val</span> clear_bounds : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="index.html#val-empty"><code>empty</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span class="keyword">val</span> addp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> list</span></code></dt><dd><p>Give the list of bindings</p></dd></dl><dl><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> <a href="../../index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dd><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Utils.RngMap.Make)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; Make</nav><header class="odoc-preamble"><h1>Module <code><span>RngMap.Make</span></code></h1><p>How to make a <code>RngMap</code> from a <a href="../module-type-LenObject/index.html"><code>LenObject</code></a></p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Obj"><a href="#argument-1-Obj" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Obj/index.html">Obj</a></span><span> : <a href="../module-type-LenObject/index.html">LenObject</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span><span class="keyword">type</span> obj</span><span> = <a href="argument-1-Obj/index.html#type-t">Obj.t</a></span></code></div><div class="spec-doc"><p>The type of the contained object</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span><span class="keyword">type</span> obj_off</span><span> = <a href="#type-obj">obj</a> * int</span></code></div><div class="spec-doc"><p>The type of an object with an offset</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of the map from address ranges to <a href="#type-obj"><code>obj</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>An empty <code>RngMap</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span><span class="keyword">val</span> is_in : <span><span class="label">objaddr</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test if an address is inside the object at address <code>objaddr</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at"><a href="#val-at" class="anchor"></a><code><span><span class="keyword">val</span> at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a></span></code></div><div class="spec-doc"><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address. <code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span><span class="keyword">val</span> at_off : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj_off">obj_off</a></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object</p><pre class="language-ocaml"><code>at_off map addr = (obj, off) </code></pre><p>means:</p><pre>   |                      |           |         |
+ map 0                 obj start    point    obj end
+   |&lt;--------------addr--------------&gt;|
+                          |&lt;---off---&gt;|
+                          |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_off_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object. See <a href="#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span><span class="keyword">val</span> clear_at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear the object containing the address if any</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span><span class="keyword">val</span> clear_crop : 
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">crop</span>:<span>(<span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span><span class="keyword">val</span> clear_bounds : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="#val-empty"><code>empty</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span><span class="keyword">val</span> addp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="#type-obj">obj</a>)</span> list</span></span></code></div><div class="spec-doc"><p>Give the list of bindings</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="#type-obj">obj</a>)</span> <a href="../../Seq/index.html#type-t">Seq.t</a></span></span></code></div><div class="spec-doc"><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/PairLenObject/argument-1-Obj/index.html b/doc/html/read-dwarf/Utils/RngMap/PairLenObject/argument-1-Obj/index.html
index 46964308..261aa2c9 100644
--- a/doc/html/read-dwarf/Utils/RngMap/PairLenObject/argument-1-Obj/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/PairLenObject/argument-1-Obj/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Obj (read-dwarf.Utils.RngMap.PairLenObject.1-Obj)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">RngMap</a> &#x00BB; <a href="../index.html">PairLenObject</a> &#x00BB; 1-Obj</nav><h1>Parameter <code>PairLenObject.1-Obj</code></h1></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A type, for functors that accept generic types</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Obj (read-dwarf.Utils.RngMap.PairLenObject.Obj)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../../index.html">Index</a> &#x00BB; <a href="../../../../index.html">read-dwarf</a> &#x00BB; <a href="../../../index.html">Utils</a> &#x00BB; <a href="../../index.html">RngMap</a> &#x00BB; <a href="../index.html">PairLenObject</a> &#x00BB; Obj</nav><header class="odoc-preamble"><h1>Parameter <code><span>PairLenObject.Obj</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>A type, for functors that accept generic types</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/PairLenObject/index.html b/doc/html/read-dwarf/Utils/RngMap/PairLenObject/index.html
index 972eb08f..d5414133 100644
--- a/doc/html/read-dwarf/Utils/RngMap/PairLenObject/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/PairLenObject/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>PairLenObject (read-dwarf.Utils.RngMap.PairLenObject)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; PairLenObject</nav><h1>Module <code>RngMap.PairLenObject</code></h1><p>For types that do not have an inner length representation, we add it with a pair</p></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Obj/index.html">Obj</a> : <a href="../index.html#module-type-Object">Object</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="argument-1-Obj/index.html#type-t">Obj.t</a> * int</code></dt><dd><p>The type to be indexed by starting addresses, must have a length</p></dd></dl><dl><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>The type of range end</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>PairLenObject (read-dwarf.Utils.RngMap.PairLenObject)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; PairLenObject</nav><header class="odoc-preamble"><h1>Module <code><span>RngMap.PairLenObject</span></code></h1><p>For types that do not have an inner length representation, we add it with a pair</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Obj"><a href="#argument-1-Obj" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Obj/index.html">Obj</a></span><span> : <a href="../module-type-Object/index.html">Object</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = <a href="argument-1-Obj/index.html#type-t">Obj.t</a> * int</span></code></div><div class="spec-doc"><p>The type to be indexed by starting addresses, must have a length</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>The type of range end</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/index.html b/doc/html/read-dwarf/Utils/RngMap/index.html
index 64b9d1f9..192e8d2b 100644
--- a/doc/html/read-dwarf/Utils/RngMap/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>RngMap (read-dwarf.Utils.RngMap)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; RngMap</nav><h1>Module <code>Utils.RngMap</code></h1></header><aside><p>A module giving a map indexing data with address ranges and providing access to quick access to data corresponding to any value in-between.</p><p>Each address is bound to at most one object so the ranges are not allowed to overlap.</p><p>In practice you dont specify the range. The size of the bound range is provided by the stored object itself that is assumed to have a length. The stored object must thus provide a <code>len</code> function as specfified by the <a href="module-type-LenObject/index.html"><code>LenObject</code></a> signature. However a length can be added to any <a href="module-type-Object/index.html"><code>Object</code></a> using <a href="PairLenObject/index.html"><code>PairLenObject</code></a></p><p>An important remark is that maps are perfectly allowed to have negative addresses, and will considered negative integer as negative addresses. An object of size 7 starting at -4 will end at 3</p><p>For now, this has a pure immutable interface.</p></aside><dl><dt class="spec module" id="module-IMap"><a href="#module-IMap" class="anchor"></a><code><span class="keyword">module</span> <a href="IMap/index.html">IMap</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>An integer map: <code>Map.Make(Int)</code></p></dd></dl><dl><dt class="spec module-type" id="module-type-Object"><a href="#module-type-Object" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Object/index.html">Object</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>A module that represent a simple type with no operation</p></dd></dl><dl><dt class="spec module-type" id="module-type-LenObject"><a href="#module-type-LenObject" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-LenObject/index.html">LenObject</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>A module for type that have a concept of length in the rngMap context</p></dd></dl><dl><dt class="spec module" id="module-PairLenObject"><a href="#module-PairLenObject" class="anchor"></a><code><span class="keyword">module</span> <a href="PairLenObject/index.html">PairLenObject</a> : <span class="keyword">functor</span> (<a href="PairLenObject/argument-1-Obj/index.html">Obj</a> : <a href="index.html#module-type-Object">Object</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-LenObject">LenObject</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="PairLenObject/index.html#type-t">t</a> = <a href="PairLenObject/argument-1-Obj/index.html#type-t">Obj.t</a> * int</code></dt><dd><p>For types that do not have an inner length representation, we add it with a pair</p></dd></dl><dl><dt class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The signature of the range map</p></dd></dl><dl><dt class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span class="keyword">module</span> <a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-Obj/index.html">Obj</a> : <a href="index.html#module-type-LenObject">LenObject</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-S">S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="Make/index.html#type-obj">obj</a> = <a href="Make/argument-1-Obj/index.html#type-t">Obj.t</a></code></dt><dd><p>How to make a <code>RngMap</code> from a <a href="module-type-LenObject/index.html"><code>LenObject</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>RngMap (read-dwarf.Utils.RngMap)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; RngMap</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.RngMap</span></code></h1><p>A module giving a map indexing data with address ranges and providing access to quick access to data corresponding to any value in-between.</p><p>Each address is bound to at most one object so the ranges are not allowed to overlap.</p><p>In practice you dont specify the range. The size of the bound range is provided by the stored object itself that is assumed to have a length. The stored object must thus provide a <code>len</code> function as specfified by the <a href="module-type-LenObject/index.html"><code>LenObject</code></a> signature. However a length can be added to any <a href="module-type-Object/index.html"><code>Object</code></a> using <a href="PairLenObject/index.html"><code>PairLenObject</code></a></p><p>An important remark is that maps are perfectly allowed to have negative addresses, and will considered negative integer as negative addresses. An object of size 7 starting at -4 will end at 3</p><p>For now, this has a pure immutable interface.</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-IMap"><a href="#module-IMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IMap/index.html">IMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>An integer map: <code>Map.Make(Int)</code></p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-Object"><a href="#module-type-Object" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Object/index.html">Object</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A module that represent a simple type with no operation</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-LenObject"><a href="#module-type-LenObject" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-LenObject/index.html">LenObject</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A module for type that have a concept of length in the rngMap context</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-PairLenObject"><a href="#module-PairLenObject" class="anchor"></a><code><span><span class="keyword">module</span> <a href="PairLenObject/index.html">PairLenObject</a></span><span> (<a href="PairLenObject/argument-1-Obj/index.html">Obj</a> : <a href="module-type-Object/index.html">Object</a>) : <a href="module-type-LenObject/index.html">LenObject</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-LenObject/index.html#type-t">t</a> = <a href="PairLenObject/argument-1-Obj/index.html#type-t">Obj.t</a> * int</span></span></code></div><div class="spec-doc"><p>For types that do not have an inner length representation, we add it with a pair</p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The signature of the range map</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Make/index.html">Make</a></span><span> (<a href="Make/argument-1-Obj/index.html">Obj</a> : <a href="module-type-LenObject/index.html">LenObject</a>) : <a href="module-type-S/index.html">S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-obj">obj</a> = <a href="Make/argument-1-Obj/index.html#type-t">Obj.t</a></span></span></code></div><div class="spec-doc"><p>How to make a <code>RngMap</code> from a <a href="module-type-LenObject/index.html"><code>LenObject</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/module-type-LenObject/index.html b/doc/html/read-dwarf/Utils/RngMap/module-type-LenObject/index.html
index 0bf6665c..ca11f439 100644
--- a/doc/html/read-dwarf/Utils/RngMap/module-type-LenObject/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/module-type-LenObject/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>LenObject (read-dwarf.Utils.RngMap.LenObject)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; LenObject</nav><h1>Module type <code>RngMap.LenObject</code></h1><p>A module for type that have a concept of length in the rngMap context</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type to be indexed by starting addresses, must have a length</p></dd></dl><dl><dt class="spec value" id="val-len"><a href="#val-len" class="anchor"></a><code><span class="keyword">val</span> len : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>The type of range end</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>LenObject (read-dwarf.Utils.RngMap.LenObject)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; LenObject</nav><header class="odoc-preamble"><h1>Module type <code><span>RngMap.LenObject</span></code></h1><p>A module for type that have a concept of length in the rngMap context</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type to be indexed by starting addresses, must have a length</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-len"><a href="#val-len" class="anchor"></a><code><span><span class="keyword">val</span> len : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>The type of range end</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/module-type-Object/index.html b/doc/html/read-dwarf/Utils/RngMap/module-type-Object/index.html
index f1ac2c22..e6f238f5 100644
--- a/doc/html/read-dwarf/Utils/RngMap/module-type-Object/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/module-type-Object/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Object (read-dwarf.Utils.RngMap.Object)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; Object</nav><h1>Module type <code>RngMap.Object</code></h1><p>A module that represent a simple type with no operation</p></header><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A type, for functors that accept generic types</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Object (read-dwarf.Utils.RngMap.Object)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; Object</nav><header class="odoc-preamble"><h1>Module type <code><span>RngMap.Object</span></code></h1><p>A module that represent a simple type with no operation</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>A type, for functors that accept generic types</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/RngMap/module-type-S/index.html b/doc/html/read-dwarf/Utils/RngMap/module-type-S/index.html
index 770cae6d..b5aee7fe 100644
--- a/doc/html/read-dwarf/Utils/RngMap/module-type-S/index.html
+++ b/doc/html/read-dwarf/Utils/RngMap/module-type-S/index.html
@@ -1,6 +1,11 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Utils.RngMap.S)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; S</nav><h1>Module type <code>RngMap.S</code></h1><p>The signature of the range map</p></header><dl><dt class="spec type" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span class="keyword">type</span> obj</code></dt><dd><p>The type of the contained object</p></dd></dl><dl><dt class="spec type" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span class="keyword">type</span> obj_off</code><code> = <a href="index.html#type-obj">obj</a> * int</code></dt><dd><p>The type of an object with an offset</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of the map from address ranges to <a href="index.html#type-obj"><code>obj</code></a></p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <a href="index.html#type-t">t</a></code></dt><dd><p>An empty <code>RngMap</code></p></dd></dl><dl><dt class="spec value" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span class="keyword">val</span> is_in : <span>objaddr:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bool</code></dt><dd><p>Test if an address is inside the object at address <code>objaddr</code></p></dd></dl><dl><dt class="spec value" id="val-at"><a href="#val-at" class="anchor"></a><code><span class="keyword">val</span> at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a></code></dt><dd><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span class="keyword">val</span> at_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj">obj</a> option</span></code></dt><dd><p>Get the object containing the address. <code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span class="keyword">val</span> at_off : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object</p><pre><code class="ml">at_off map addr = (obj, off) </code></pre><p>means:</p><pre>         |                      |           |         |
-       map 0                 obj start    point    obj end
-         |&lt;--------------addr--------------&gt;|
-                                |&lt;---off---&gt;|
-                                |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span class="keyword">val</span> at_off_opt : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span><a href="index.html#type-obj_off">obj_off</a> option</span></code></dt><dd><p>Get the object containing the address and the offset of the address inside the object. See <a href="index.html#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></dd></dl><dl><dt class="spec value" id="val-update"><a href="#val-update" class="anchor"></a><code><span class="keyword">val</span> update : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></dd></dl><dl><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Map a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects</p></dd></dl><dl><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iter a function over all the objects with their address</p></dd></dl><dl><dt class="spec value" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span class="keyword">val</span> clear_at : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear the object containing the address if any</p></dd></dl><dl><dt class="spec value" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span class="keyword">val</span> clear : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="index.html#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="index.html#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></dd></dl><dl><dt class="spec value" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span class="keyword">val</span> clear_crop : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span>crop:<span>(<span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a>)</span></span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></dd></dl><dl><dt class="spec value" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span class="keyword">val</span> clear_bounds : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Same as <a href="index.html#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="index.html#val-empty"><code>empty</code></a>.</p></dd></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <a href="index.html#type-obj">obj</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span class="keyword">val</span> addp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-obj_off">obj_off</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></dd></dl><dl><dt class="spec value" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span class="keyword">val</span> bindings : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> list</span></code></dt><dd><p>Give the list of bindings</p></dd></dl><dl><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>?&#8288;endp:int</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * <a href="index.html#type-obj">obj</a>)</span> <a href="../../index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dd><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Utils.RngMap.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Utils</a> &#x00BB; <a href="../index.html">RngMap</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Module type <code><span>RngMap.S</span></code></h1><p>The signature of the range map</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-obj"><a href="#type-obj" class="anchor"></a><code><span><span class="keyword">type</span> obj</span></code></div><div class="spec-doc"><p>The type of the contained object</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-obj_off"><a href="#type-obj_off" class="anchor"></a><code><span><span class="keyword">type</span> obj_off</span><span> = <a href="#type-obj">obj</a> * int</span></code></div><div class="spec-doc"><p>The type of an object with an offset</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of the map from address ranges to <a href="#type-obj"><code>obj</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>An empty <code>RngMap</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_in"><a href="#val-is_in" class="anchor"></a><code><span><span class="keyword">val</span> is_in : <span><span class="label">objaddr</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Test if an address is inside the object at address <code>objaddr</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at"><a href="#val-at" class="anchor"></a><code><span><span class="keyword">val</span> at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a></span></code></div><div class="spec-doc"><p>Get the object containing the address. Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_opt"><a href="#val-at_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address. <code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off"><a href="#val-at_off" class="anchor"></a><code><span><span class="keyword">val</span> at_off : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj_off">obj_off</a></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object</p><pre class="language-ocaml"><code>at_off map addr = (obj, off) </code></pre><p>means:</p><pre>   |                      |           |         |
+ map 0                 obj start    point    obj end
+   |&lt;--------------addr--------------&gt;|
+                          |&lt;---off---&gt;|
+                          |&lt;------len obj------&gt;|</pre><p>In other words, <code>at_off</code> allow a change of coordinate from the map frame to the object frame.</p><p>Throw <code>Not_found</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-at_off_opt"><a href="#val-at_off_opt" class="anchor"></a><code><span><span class="keyword">val</span> at_off_opt : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> option</span></span></code></div><div class="spec-doc"><p>Get the object containing the address and the offset of the address inside the object. See <a href="#val-at_off"><code>at_off</code></a> for more explanation.</p><p><code>None</code> if no object contains the address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Update the binding containing the provided address. If no binding contained the address, this is a no-op</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Map a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iter a function over all the objects with their address</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_at"><a href="#val-clear_at" class="anchor"></a><code><span><span class="keyword">val</span> clear_at : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear the object containing the address if any</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear"><a href="#val-clear" class="anchor"></a><code><span><span class="keyword">val</span> clear : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If an object is partially in the specified block. It will be removed entirely.</p><p>See <a href="#val-clear_crop"><code>clear_crop</code></a> for a different behavior. See <a href="#val-clear_bounds"><code>clear_bounds</code></a> to allow some bounds to be infinity.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_crop"><a href="#val-clear_crop" class="anchor"></a><code><span><span class="keyword">val</span> clear_crop : 
+  <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="label">crop</span>:<span>(<span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-obj">obj</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Clear an area of the RngMap.</p><p>If a block is partially in the specified block, It will be cropped by using the provided crop function.</p><p><code>crop ~pos ~len obj</code> is supposed to crop the object <code>obj</code> and keep only the segment <code>[pos:pos +len)</code> of it (in the object coordinate frame).</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clear_bounds"><a href="#val-clear_bounds" class="anchor"></a><code><span><span class="keyword">val</span> clear_bounds : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Same as <a href="#val-clear"><code>clear</code></a> but if a bound is missing, then we erase until infinity in that direction. The target interval is <code>[start:endp)</code>.</p><p>In particular <code>clear_bounds map = </code><a href="#val-empty"><code>empty</code></a>.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj">obj</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-addp"><a href="#val-addp" class="anchor"></a><code><span><span class="keyword">val</span> addp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-obj_off">obj_off</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Add an object at a specific address. The whole range of addresses covered by the object must be free</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bindings"><a href="#val-bindings" class="anchor"></a><code><span><span class="keyword">val</span> bindings : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="#type-obj">obj</a>)</span> list</span></span></code></div><div class="spec-doc"><p>Give the list of bindings</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="optlabel">?endp</span>:int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <a href="#type-obj">obj</a>)</span> <a href="../../Seq/index.html#type-t">Seq.t</a></span></span></code></div><div class="spec-doc"><p>Return a sequence of all the object overlapping the range <code>[start:endp)</code>. The first and last element may not be entierly contained in the ranged. If any bound is unspecified, it goes to infinity in that direction.</p><p>In particular <code>to_seq map</code> will iterate the entiere <code>RngMap</code></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Seq/index.html b/doc/html/read-dwarf/Utils/Seq/index.html
index bf1a944c..93f08152 100644
--- a/doc/html/read-dwarf/Utils/Seq/index.html
+++ b/doc/html/read-dwarf/Utils/Seq/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Seq (read-dwarf.Utils.Seq)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Seq</nav><h1>Module <code>Utils.Seq</code></h1></header><aside><p>This module is for extending the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Seq.html">Seq</a> module of the standard library</p></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.Seq</code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code><code> = unit <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-node">node</a></span></code></dt><dt class="spec type" id="type-node"><a href="#type-node" class="anchor"></a><code><span class="keyword">and</span> <span>'a node</span></code><code> = <span><span class="type-var">'a</span> Stdlib__seq.node</span></code><code> = </code><table class="variant"><tr id="type-node.Nil" class="anchored"><td class="def constructor"><a href="#type-node.Nil" class="anchor"></a><code>| </code><code><span class="constructor">Nil</span></code></td></tr><tr id="type-node.Cons" class="anchored"><td class="def constructor"><a href="#type-node.Cons" class="anchor"></a><code>| </code><code><span class="constructor">Cons</span> <span class="keyword">of</span> <span class="type-var">'a</span> * <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></td></tr></table></dt></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-return"><a href="#val-return" class="anchor"></a><code><span class="keyword">val</span> return : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span class="keyword">val</span> filter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span class="keyword">val</span> filter_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-flat_map"><a href="#val-flat_map" class="anchor"></a><code><span class="keyword">val</span> flat_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span class="keyword">val</span> fold_left : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-add_count"><a href="#val-add_count" class="anchor"></a><code><span class="keyword">val</span> add_count : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Add a counter starting at <code>start</code> (default 0) in front of each element of the sequence</p></dd></dl><dl><dt class="spec value" id="val-iota"><a href="#val-iota" class="anchor"></a><code><span class="keyword">val</span> iota : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>int <a href="index.html#type-t">t</a></span></code></dt><dd><p>Generate an integer sequence up to <code>len</code>. Optionally may start at <code>start</code> instead of 0</p></dd></dl><dl><dt class="spec value" id="val-iota_step_up"><a href="#val-iota_step_up" class="anchor"></a><code><span class="keyword">val</span> iota_step_up : <span>?&#8288;start:int</span> <span>&#45;&gt;</span> <span>step:int</span> <span>&#45;&gt;</span> <span>endi:int</span> <span>&#45;&gt;</span> <span>int <a href="index.html#type-t">t</a></span></code></dt><dd><p>Generate an integer sequence up to <code>endi</code> by stepping <code>step</code>. Optionally may start at <code>start</code> instead of 0</p></dd></dl><dl><dt class="spec value" id="val-stop_at"><a href="#val-stop_at" class="anchor"></a><code><span class="keyword">val</span> stop_at : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Make the sequence stop when the condition is met</p></dd></dl><dl><dt class="spec value" id="val-cons"><a href="#val-cons" class="anchor"></a><code><span class="keyword">val</span> cons : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-node">node</a></span></code></dt><dd><p>Add a new element in front of the sequence. That element will appear first before the rest of the sequence.</p><p>Added to <code>Stdlib</code> in Ocaml 4.11</p></dd></dl><dl><dt class="spec value" id="val-find_map"><a href="#val-find_map" class="anchor"></a><code><span class="keyword">val</span> find_map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> option</span></code></dt><dd><p>Applies the specified function to the elements of the sequence in order, and returns the first result of the form <code>Some v</code>, or <code>None</code> if no such result was returned.</p><p>See <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALfind_map"><code>List.find_map</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Seq (read-dwarf.Utils.Seq)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Seq</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Seq</span></code></h1><p>This module is for extending the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Seq.html">Seq</a> module of the standard library</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.Seq <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>!'a t</span></span><span> = <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-node">node</a></span></span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-node"><a href="#type-node" class="anchor"></a><code><span><span class="keyword">and</span> <span>!'a node</span></span><span> = <span><span class="type-var">'a</span> <span class="xref-unresolved">Stdlib__Seq</span>.node</span></span><span> = </span></code><ol><li id="type-node.Nil" class="def variant constructor anchored"><a href="#type-node.Nil" class="anchor"></a><code><span>| </span><span><span class="constructor">Nil</span></span></code></li><li id="type-node.Cons" class="def variant constructor anchored"><a href="#type-node.Cons" class="anchor"></a><code><span>| </span><span><span class="constructor">Cons</span> <span class="keyword">of</span> <span class="type-var">'a</span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></li></ol></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_empty"><a href="#val-is_empty" class="anchor"></a><code><span><span class="keyword">val</span> is_empty : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uncons"><a href="#val-uncons" class="anchor"></a><code><span><span class="keyword">val</span> uncons : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span>)</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_lefti"><a href="#val-fold_lefti" class="anchor"></a><code><span><span class="keyword">val</span> fold_lefti : <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find"><a href="#val-find" class="anchor"></a><code><span><span class="keyword">val</span> find : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_index"><a href="#val-find_index" class="anchor"></a><code><span><span class="keyword">val</span> find_index : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_mapi"><a href="#val-find_mapi" class="anchor"></a><code><span><span class="keyword">val</span> find_mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span><span class="keyword">val</span> iter2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left2"><a href="#val-fold_left2" class="anchor"></a><code><span><span class="keyword">val</span> fold_left2 : <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all2"><a href="#val-for_all2" class="anchor"></a><code><span><span class="keyword">val</span> for_all2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists2"><a href="#val-exists2" class="anchor"></a><code><span><span class="keyword">val</span> exists2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-return"><a href="#val-return" class="anchor"></a><code><span><span class="keyword">val</span> return : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unfold"><a href="#val-unfold" class="anchor"></a><code><span><span class="keyword">val</span> unfold : <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-repeat"><a href="#val-repeat" class="anchor"></a><code><span><span class="keyword">val</span> repeat : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-forever"><a href="#val-forever" class="anchor"></a><code><span><span class="keyword">val</span> forever : <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cycle"><a href="#val-cycle" class="anchor"></a><code><span><span class="keyword">val</span> cycle : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iterate"><a href="#val-iterate" class="anchor"></a><code><span><span class="keyword">val</span> iterate : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span><span class="keyword">val</span> filter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_map"><a href="#val-filter_map" class="anchor"></a><code><span><span class="keyword">val</span> filter_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scan"><a href="#val-scan" class="anchor"></a><code><span><span class="keyword">val</span> scan : <span><span>(<span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take"><a href="#val-take" class="anchor"></a><code><span><span class="keyword">val</span> take : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-drop"><a href="#val-drop" class="anchor"></a><code><span><span class="keyword">val</span> drop : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-take_while"><a href="#val-take_while" class="anchor"></a><code><span><span class="keyword">val</span> take_while : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-drop_while"><a href="#val-drop_while" class="anchor"></a><code><span><span class="keyword">val</span> drop_while : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-group"><a href="#val-group" class="anchor"></a><code><span><span class="keyword">val</span> group : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-memoize"><a href="#val-memoize" class="anchor"></a><code><span><span class="keyword">val</span> memoize : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Forced_twice"><a href="#exception-Forced_twice" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Forced_twice</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-once"><a href="#val-once" class="anchor"></a><code><span><span class="keyword">val</span> once : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose"><a href="#val-transpose" class="anchor"></a><code><span><span class="keyword">val</span> transpose : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-append"><a href="#val-append" class="anchor"></a><code><span><span class="keyword">val</span> append : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span><span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flat_map"><a href="#val-flat_map" class="anchor"></a><code><span><span class="keyword">val</span> flat_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_map"><a href="#val-concat_map" class="anchor"></a><code><span><span class="keyword">val</span> concat_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-zip"><a href="#val-zip" class="anchor"></a><code><span><span class="keyword">val</span> zip : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-interleave"><a href="#val-interleave" class="anchor"></a><code><span><span class="keyword">val</span> interleave : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sorted_merge"><a href="#val-sorted_merge" class="anchor"></a><code><span><span class="keyword">val</span> sorted_merge : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> int)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-product"><a href="#val-product" class="anchor"></a><code><span><span class="keyword">val</span> product : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_product"><a href="#val-map_product" class="anchor"></a><code><span><span class="keyword">val</span> map_product : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unzip"><a href="#val-unzip" class="anchor"></a><code><span><span class="keyword">val</span> unzip : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span><span>(<span class="type-var">'a</span> * <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition_map"><a href="#val-partition_map" class="anchor"></a><code><span><span class="keyword">val</span> partition_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'c</span>)</span> <span class="xref-unresolved">Stdlib</span>.Either.t</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-partition"><a href="#val-partition" class="anchor"></a><code><span><span class="keyword">val</span> partition : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span> * <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_dispenser"><a href="#val-of_dispenser" class="anchor"></a><code><span><span class="keyword">val</span> of_dispenser : <span><span>(<span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_dispenser"><a href="#val-to_dispenser" class="anchor"></a><code><span><span class="keyword">val</span> to_dispenser : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ints"><a href="#val-ints" class="anchor"></a><code><span><span class="keyword">val</span> ints : <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <a href="#type-t">t</a></span></span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_count"><a href="#val-add_count" class="anchor"></a><code><span><span class="keyword">val</span> add_count : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Add a counter starting at <code>start</code> (default 0) in front of each element of the sequence</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iota"><a href="#val-iota" class="anchor"></a><code><span><span class="keyword">val</span> iota : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Generate an integer sequence up to <code>len</code>. Optionally may start at <code>start</code> instead of 0</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iota_step_up"><a href="#val-iota_step_up" class="anchor"></a><code><span><span class="keyword">val</span> iota_step_up : <span><span class="optlabel">?start</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">step</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">endi</span>:int <span class="arrow">&#45;&gt;</span></span> <span>int <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Generate an integer sequence up to <code>endi</code> by stepping <code>step</code>. Optionally may start at <code>start</code> instead of 0</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stop_at"><a href="#val-stop_at" class="anchor"></a><code><span><span class="keyword">val</span> stop_at : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Make the sequence stop when the condition is met</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cons"><a href="#val-cons" class="anchor"></a><code><span><span class="keyword">val</span> cons : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-node">node</a></span></span></code></div><div class="spec-doc"><p>Add a new element in front of the sequence. That element will appear first before the rest of the sequence.</p><p>Added to <code>Stdlib</code> in Ocaml 4.11</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-find_map"><a href="#val-find_map" class="anchor"></a><code><span><span class="keyword">val</span> find_map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> option</span></span></code></div><div class="spec-doc"><p>Applies the specified function to the elements of the sequence in order, and returns the first result of the form <code>Some v</code>, or <code>None</code> if no such result was returned.</p><p>See <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALfind_map"><code>List.find_map</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/String/index.html b/doc/html/read-dwarf/Utils/String/index.html
index 66e26772..dec0950d 100644
--- a/doc/html/read-dwarf/Utils/String/index.html
+++ b/doc/html/read-dwarf/Utils/String/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>String (read-dwarf.Utils.String)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; String</nav><h1>Module <code>Utils.String</code></h1></header><aside><p>Extension of the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/String.html"><code>String</code></a> module of the standard library.</p></aside><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> Stdlib.String</code></span></summary><dl><dt class="spec external" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : string <span>&#45;&gt;</span> int</code></dt><dt class="spec external" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char</code></dt><dt class="spec external" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> unit</code></dt><dt class="spec external" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> bytes</code></dt></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-init"><a href="#val-init" class="anchor"></a><code><span class="keyword">val</span> init : int <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> char)</span> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span class="keyword">val</span> sub : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-fill"><a href="#val-fill" class="anchor"></a><code><span class="keyword">val</span> fill : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span class="keyword">val</span> blit : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span class="keyword">val</span> concat : string <span>&#45;&gt;</span> <span>string list</span> <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(char <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(char <span>&#45;&gt;</span> char)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> char)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-trim"><a href="#val-trim" class="anchor"></a><code><span class="keyword">val</span> trim : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-escaped"><a href="#val-escaped" class="anchor"></a><code><span class="keyword">val</span> escaped : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-index"><a href="#val-index" class="anchor"></a><code><span class="keyword">val</span> index : string <span>&#45;&gt;</span> char <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-index_opt"><a href="#val-index_opt" class="anchor"></a><code><span class="keyword">val</span> index_opt : string <span>&#45;&gt;</span> char <span>&#45;&gt;</span> <span>int option</span></code></dt><dt class="spec value" id="val-rindex"><a href="#val-rindex" class="anchor"></a><code><span class="keyword">val</span> rindex : string <span>&#45;&gt;</span> char <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-rindex_opt"><a href="#val-rindex_opt" class="anchor"></a><code><span class="keyword">val</span> rindex_opt : string <span>&#45;&gt;</span> char <span>&#45;&gt;</span> <span>int option</span></code></dt><dt class="spec value" id="val-index_from"><a href="#val-index_from" class="anchor"></a><code><span class="keyword">val</span> index_from : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-index_from_opt"><a href="#val-index_from_opt" class="anchor"></a><code><span class="keyword">val</span> index_from_opt : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> <span>int option</span></code></dt><dt class="spec value" id="val-rindex_from"><a href="#val-rindex_from" class="anchor"></a><code><span class="keyword">val</span> rindex_from : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-rindex_from_opt"><a href="#val-rindex_from_opt" class="anchor"></a><code><span class="keyword">val</span> rindex_from_opt : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> <span>int option</span></code></dt><dt class="spec value" id="val-contains"><a href="#val-contains" class="anchor"></a><code><span class="keyword">val</span> contains : string <span>&#45;&gt;</span> char <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-contains_from"><a href="#val-contains_from" class="anchor"></a><code><span class="keyword">val</span> contains_from : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-rcontains_from"><a href="#val-rcontains_from" class="anchor"></a><code><span class="keyword">val</span> rcontains_from : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-uppercase"><a href="#val-uppercase" class="anchor"></a><code><span class="keyword">val</span> uppercase : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-lowercase"><a href="#val-lowercase" class="anchor"></a><code><span class="keyword">val</span> lowercase : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-capitalize"><a href="#val-capitalize" class="anchor"></a><code><span class="keyword">val</span> capitalize : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-uncapitalize"><a href="#val-uncapitalize" class="anchor"></a><code><span class="keyword">val</span> uncapitalize : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-uppercase_ascii"><a href="#val-uppercase_ascii" class="anchor"></a><code><span class="keyword">val</span> uppercase_ascii : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-lowercase_ascii"><a href="#val-lowercase_ascii" class="anchor"></a><code><span class="keyword">val</span> lowercase_ascii : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-capitalize_ascii"><a href="#val-capitalize_ascii" class="anchor"></a><code><span class="keyword">val</span> capitalize_ascii : string <span>&#45;&gt;</span> string</code></dt><dt class="spec value" id="val-uncapitalize_ascii"><a href="#val-uncapitalize_ascii" class="anchor"></a><code><span class="keyword">val</span> uncapitalize_ascii : string <span>&#45;&gt;</span> string</code></dt></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = string</code></dt></dl><dl><dt class="spec value" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span class="keyword">val</span> compare : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-split_on_char"><a href="#val-split_on_char" class="anchor"></a><code><span class="keyword">val</span> split_on_char : char <span>&#45;&gt;</span> string <span>&#45;&gt;</span> <span>string list</span></code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span>char Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span class="keyword">val</span> to_seqi : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <span><span>(int * char)</span> Stdlib.Seq.t</span></code></dt><dt class="spec value" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span class="keyword">val</span> of_seq : <span>char Stdlib.Seq.t</span> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt></dl><dl><dt class="spec external" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span class="keyword">val</span> unsafe_get : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char</code></dt><dt class="spec external" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span class="keyword">val</span> unsafe_set : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> unit</code></dt><dt class="spec external" id="val-unsafe_blit"><a href="#val-unsafe_blit" class="anchor"></a><code><span class="keyword">val</span> unsafe_blit : string <span>&#45;&gt;</span> int <span>&#45;&gt;</span> bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dt class="spec external" id="val-unsafe_fill"><a href="#val-unsafe_fill" class="anchor"></a><code><span class="keyword">val</span> unsafe_fill : bytes <span>&#45;&gt;</span> int <span>&#45;&gt;</span> int <span>&#45;&gt;</span> char <span>&#45;&gt;</span> unit</code></dt></dl></details></div></div></div><dl><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(char <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if a predicate hold for all <code>char</code> in a string</p></dd></dl><dl><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(char <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if a predicate hold for at least one <code>char</code> in a string</p></dd></dl><dl><dt class="spec value" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span class="keyword">val</span> to_list : string <span>&#45;&gt;</span> <span>char list</span></code></dt><dd><p>Convert the list into a list of char. Probably a bad idea on large strings.</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>String (read-dwarf.Utils.String)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; String</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.String</span></code></h1><p>Extension of the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/String.html"><code>String</code></a> module of the standard library.</p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <span class="xref-unresolved">Stdlib</span>.String <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span><span> = string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> char)</span> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : string</span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span>string <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> char</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_bytes"><a href="#val-of_bytes" class="anchor"></a><code><span><span class="keyword">val</span> of_bytes : <span>bytes <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_bytes"><a href="#val-to_bytes" class="anchor"></a><code><span><span class="keyword">val</span> to_bytes : <span>string <span class="arrow">&#45;&gt;</span></span> bytes</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-blit"><a href="#val-blit" class="anchor"></a><code><span><span class="keyword">val</span> blit : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat"><a href="#val-concat" class="anchor"></a><code><span><span class="keyword">val</span> concat : <span>string <span class="arrow">&#45;&gt;</span></span> <span><span>string list</span> <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cat"><a href="#val-cat" class="anchor"></a><code><span><span class="keyword">val</span> cat : <span>string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-compare"><a href="#val-compare" class="anchor"></a><code><span><span class="keyword">val</span> compare : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-starts_with"><a href="#val-starts_with" class="anchor"></a><code><span><span class="keyword">val</span> starts_with : <span><span class="label">prefix</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ends_with"><a href="#val-ends_with" class="anchor"></a><code><span><span class="keyword">val</span> ends_with : <span><span class="label">suffix</span>:string <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-contains_from"><a href="#val-contains_from" class="anchor"></a><code><span><span class="keyword">val</span> contains_from : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rcontains_from"><a href="#val-rcontains_from" class="anchor"></a><code><span><span class="keyword">val</span> rcontains_from : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-contains"><a href="#val-contains" class="anchor"></a><code><span><span class="keyword">val</span> contains : <span>string <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_on_char"><a href="#val-split_on_char" class="anchor"></a><code><span><span class="keyword">val</span> split_on_char : <span>char <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span>string list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> char)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> char)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span>(<span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span><span class="keyword">val</span> fold_right : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'acc</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'acc</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trim"><a href="#val-trim" class="anchor"></a><code><span><span class="keyword">val</span> trim : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-escaped"><a href="#val-escaped" class="anchor"></a><code><span><span class="keyword">val</span> escaped : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uppercase_ascii"><a href="#val-uppercase_ascii" class="anchor"></a><code><span><span class="keyword">val</span> uppercase_ascii : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lowercase_ascii"><a href="#val-lowercase_ascii" class="anchor"></a><code><span><span class="keyword">val</span> lowercase_ascii : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-capitalize_ascii"><a href="#val-capitalize_ascii" class="anchor"></a><code><span><span class="keyword">val</span> capitalize_ascii : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uncapitalize_ascii"><a href="#val-uncapitalize_ascii" class="anchor"></a><code><span><span class="keyword">val</span> uncapitalize_ascii : <span>string <span class="arrow">&#45;&gt;</span></span> string</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-index_from"><a href="#val-index_from" class="anchor"></a><code><span><span class="keyword">val</span> index_from : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-index_from_opt"><a href="#val-index_from_opt" class="anchor"></a><code><span><span class="keyword">val</span> index_from_opt : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rindex_from"><a href="#val-rindex_from" class="anchor"></a><code><span><span class="keyword">val</span> rindex_from : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rindex_from_opt"><a href="#val-rindex_from_opt" class="anchor"></a><code><span><span class="keyword">val</span> rindex_from_opt : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-index"><a href="#val-index" class="anchor"></a><code><span><span class="keyword">val</span> index : <span>string <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-index_opt"><a href="#val-index_opt" class="anchor"></a><code><span><span class="keyword">val</span> index_opt : <span>string <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rindex"><a href="#val-rindex" class="anchor"></a><code><span><span class="keyword">val</span> rindex : <span>string <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rindex_opt"><a href="#val-rindex_opt" class="anchor"></a><code><span><span class="keyword">val</span> rindex_opt : <span>string <span class="arrow">&#45;&gt;</span></span> <span>char <span class="arrow">&#45;&gt;</span></span> <span>int option</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>char <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span><span class="keyword">val</span> to_seqi : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * char)</span> <span class="xref-unresolved">Stdlib</span>.Seq.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_seq"><a href="#val-of_seq" class="anchor"></a><code><span><span class="keyword">val</span> of_seq : <span><span>char <span class="xref-unresolved">Stdlib</span>.Seq.t</span> <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_utf_8_uchar"><a href="#val-get_utf_8_uchar" class="anchor"></a><code><span><span class="keyword">val</span> get_utf_8_uchar : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Uchar.utf_decode</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_valid_utf_8"><a href="#val-is_valid_utf_8" class="anchor"></a><code><span><span class="keyword">val</span> is_valid_utf_8 : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_utf_16be_uchar"><a href="#val-get_utf_16be_uchar" class="anchor"></a><code><span><span class="keyword">val</span> get_utf_16be_uchar : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Uchar.utf_decode</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_valid_utf_16be"><a href="#val-is_valid_utf_16be" class="anchor"></a><code><span><span class="keyword">val</span> is_valid_utf_16be : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_utf_16le_uchar"><a href="#val-get_utf_16le_uchar" class="anchor"></a><code><span><span class="keyword">val</span> get_utf_16le_uchar : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="xref-unresolved">Stdlib</span>.Uchar.utf_decode</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_valid_utf_16le"><a href="#val-is_valid_utf_16le" class="anchor"></a><code><span><span class="keyword">val</span> is_valid_utf_16le : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_uint8"><a href="#val-get_uint8" class="anchor"></a><code><span><span class="keyword">val</span> get_uint8 : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int8"><a href="#val-get_int8" class="anchor"></a><code><span><span class="keyword">val</span> get_int8 : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_uint16_ne"><a href="#val-get_uint16_ne" class="anchor"></a><code><span><span class="keyword">val</span> get_uint16_ne : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_uint16_be"><a href="#val-get_uint16_be" class="anchor"></a><code><span><span class="keyword">val</span> get_uint16_be : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_uint16_le"><a href="#val-get_uint16_le" class="anchor"></a><code><span><span class="keyword">val</span> get_uint16_le : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int16_ne"><a href="#val-get_int16_ne" class="anchor"></a><code><span><span class="keyword">val</span> get_int16_ne : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int16_be"><a href="#val-get_int16_be" class="anchor"></a><code><span><span class="keyword">val</span> get_int16_be : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int16_le"><a href="#val-get_int16_le" class="anchor"></a><code><span><span class="keyword">val</span> get_int16_le : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int32_ne"><a href="#val-get_int32_ne" class="anchor"></a><code><span><span class="keyword">val</span> get_int32_ne : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int32</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-seeded_hash"><a href="#val-seeded_hash" class="anchor"></a><code><span><span class="keyword">val</span> seeded_hash : <span>int <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int32_be"><a href="#val-get_int32_be" class="anchor"></a><code><span><span class="keyword">val</span> get_int32_be : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int32</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int32_le"><a href="#val-get_int32_le" class="anchor"></a><code><span><span class="keyword">val</span> get_int32_le : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int32</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int64_ne"><a href="#val-get_int64_ne" class="anchor"></a><code><span><span class="keyword">val</span> get_int64_ne : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int64</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int64_be"><a href="#val-get_int64_be" class="anchor"></a><code><span><span class="keyword">val</span> get_int64_be : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int64</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_int64_le"><a href="#val-get_int64_le" class="anchor"></a><code><span><span class="keyword">val</span> get_int64_le : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> int64</span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_get : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> char</span></code></div></div><div class="odoc-spec"><div class="spec value external anchored" id="val-unsafe_blit"><a href="#val-unsafe_blit" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_blit : <span>string <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>bytes <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if a predicate hold for all <code>char</code> in a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span>char <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if a predicate hold for at least one <code>char</code> in a string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span>string <span class="arrow">&#45;&gt;</span></span> <span>char list</span></span></code></div><div class="spec-doc"><p>Convert the list into a list of char. Probably a bad idea on large strings.</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/Vec/index.html b/doc/html/read-dwarf/Utils/Vec/index.html
index 285eb94f..ca9f9f32 100644
--- a/doc/html/read-dwarf/Utils/Vec/index.html
+++ b/doc/html/read-dwarf/Utils/Vec/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Vec (read-dwarf.Utils.Vec)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Vec</nav><h1>Module <code>Utils.Vec</code></h1></header><aside><p>This module provide a resizable array. It is a rename of Res.array with added features</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code></dt><dd><p>The vector type</p></dd></dl><dl><dt class="spec value" id="val-length"><a href="#val-length" class="anchor"></a><code><span class="keyword">val</span> length : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : unit <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span class="keyword">val</span> mem : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span class="keyword">val</span> unsafe_get : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span class="keyword">val</span> unsafe_set : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-update"><a href="#val-update" class="anchor"></a><code><span class="keyword">val</span> update : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-unsafe_update"><a href="#val-unsafe_update" class="anchor"></a><code><span class="keyword">val</span> unsafe_update : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span class="keyword">val</span> copy : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span class="keyword">val</span> for_all : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span class="keyword">val</span> exists : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> bool)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-map"><a href="#val-map" class="anchor"></a><code><span class="keyword">val</span> map : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span class="keyword">val</span> mapi : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span class="keyword">val</span> iter : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span class="keyword">val</span> iteri : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-iter_until"><a href="#val-iter_until" class="anchor"></a><code><span class="keyword">val</span> iter_until : <span>limit:int</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Iterates until the <code>limit</code>. If the vector is shorter, this is a plain <a href="index.html#val-iter"><code>iter</code></a></p></dd></dl><dl><dt class="spec value" id="val-iteri_until"><a href="#val-iteri_until" class="anchor"></a><code><span class="keyword">val</span> iteri_until : <span>limit:int</span> <span>&#45;&gt;</span> <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-iter_until"><code>iter_until</code></a> but with the index</p></dd></dl><dl><dt class="spec value" id="val-iteri_rev"><a href="#val-iteri_rev" class="anchor"></a><code><span class="keyword">val</span> iteri_rev : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-iteri"><code>iteri</code></a> but starting at the end</p></dd></dl><dl><dt class="spec value" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span class="keyword">val</span> to_list : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> list</span></code></dt><dt class="spec value" id="val-to_listi"><a href="#val-to_listi" class="anchor"></a><code><span class="keyword">val</span> to_listi : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> list</span></code></dt><dt class="spec value" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span class="keyword">val</span> fold_right : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-foldi_right"><a href="#val-foldi_right" class="anchor"></a><code><span class="keyword">val</span> foldi_right : <span>(int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span class="keyword">val</span> fold_left : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dt class="spec value" id="val-foldi_left"><a href="#val-foldi_left" class="anchor"></a><code><span class="keyword">val</span> foldi_left : <span>(int <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dt class="spec value" id="val-add_one"><a href="#val-add_one" class="anchor"></a><code><span class="keyword">val</span> add_one : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add a new element at the end of the vector</p></dd></dl><dl><dt class="spec value" id="val-remove_one"><a href="#val-remove_one" class="anchor"></a><code><span class="keyword">val</span> remove_one : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove the last element of the vector</p></dd></dl><dl><dt class="spec value" id="val-remove_n"><a href="#val-remove_n" class="anchor"></a><code><span class="keyword">val</span> remove_n : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Remove the last n elements of the vector</p></dd></dl><dl><dt class="spec value" id="val-to_array"><a href="#val-to_array" class="anchor"></a><code><span class="keyword">val</span> to_array : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> array</span></code></dt><dt class="spec value" id="val-of_array"><a href="#val-of_array" class="anchor"></a><code><span class="keyword">val</span> of_array : <span><span class="type-var">'a</span> array</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-ensure"><a href="#val-ensure" class="anchor"></a><code><span class="keyword">val</span> ensure : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Ensure that the vector has size at least the int by resizing if needed The value provided will be use to set the newly created values.</p></dd></dl><dl><dt class="spec value" id="val-keep"><a href="#val-keep" class="anchor"></a><code><span class="keyword">val</span> keep : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> unit</code></dt><dd><p>Keep only the specified number of element. If the vector was smaller, do nothing.</p></dd></dl><dl><dt class="spec value" id="val-resize"><a href="#val-resize" class="anchor"></a><code><span class="keyword">val</span> resize : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Resize the vector to the specified size. The value provided will be use to set the newly created values if relevant</p></dd></dl><dl><dt class="spec value" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span class="keyword">val</span> map2 : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> <span class="type-var">'c</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'b</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'c</span> <a href="index.html#type-t">t</a></span></code></dt><dt class="spec value" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span class="keyword">val</span> map_mut : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Map the function on the vector mutably by replacing each cell by the result of the function</p></dd></dl><dl><dt class="spec value" id="val-map_mut_until"><a href="#val-map_mut_until" class="anchor"></a><code><span class="keyword">val</span> map_mut_until : <span>limit:int</span> <span>&#45;&gt;</span> <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'a</span>)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Same as <a href="index.html#val-map_mut"><code>map_mut</code></a> but stop at <code>limit</code>. If the vector is shorter than <code>limit</code> this is a plain <a href="index.html#val-map_mut"><code>map_mut</code></a></p></dd></dl><dl><dt class="spec value" id="val-fill_all"><a href="#val-fill_all" class="anchor"></a><code><span class="keyword">val</span> fill_all : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Write the value in all the cells of the vector</p></dd></dl><dl><dt class="spec value" id="val-insert"><a href="#val-insert" class="anchor"></a><code><span class="keyword">val</span> insert : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> int <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Insert an element at the specified position that may be one past the end</p></dd></dl><dl><dt class="spec value" id="val-to_seq_sub"><a href="#val-to_seq_sub" class="anchor"></a><code><span class="keyword">val</span> to_seq_sub : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dt class="spec value" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span class="keyword">val</span> to_seq : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="../index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dt class="spec value" id="val-to_seqi_sub"><a href="#val-to_seqi_sub" class="anchor"></a><code><span class="keyword">val</span> to_seqi_sub : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span>pos:int</span> <span>&#45;&gt;</span> <span>len:int</span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dt class="spec value" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span class="keyword">val</span> to_seqi : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../index.html#module-Seq">Utils.Seq</a>.t</span></code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Vector pretty printer</p></dd></dl><dl><dt class="spec value" id="val-ppi"><a href="#val-ppi" class="anchor"></a><code><span class="keyword">val</span> ppi : <span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document)</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <a href="../index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Vector pretty printer that also prints the index of each element using <a href="../Pp/index.html#val-mapping"><code>Pp.mapping</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Vec (read-dwarf.Utils.Vec)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; Vec</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.Vec</span></code></h1><p>This module provide a resizable array. It is a rename of Res.array with added features</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span></code></div><div class="spec-doc"><p>The vector type</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-length"><a href="#val-length" class="anchor"></a><code><span><span class="keyword">val</span> length : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mem"><a href="#val-mem" class="anchor"></a><code><span><span class="keyword">val</span> mem : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_get"><a href="#val-unsafe_get" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_get : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_set"><a href="#val-unsafe_set" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_set : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-update"><a href="#val-update" class="anchor"></a><code><span><span class="keyword">val</span> update : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unsafe_update"><a href="#val-unsafe_update" class="anchor"></a><code><span><span class="keyword">val</span> unsafe_update : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> bool)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_until"><a href="#val-iter_until" class="anchor"></a><code><span><span class="keyword">val</span> iter_until : <span><span class="label">limit</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Iterates until the <code>limit</code>. If the vector is shorter, this is a plain <a href="#val-iter"><code>iter</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri_until"><a href="#val-iteri_until" class="anchor"></a><code><span><span class="keyword">val</span> iteri_until : <span><span class="label">limit</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-iter_until"><code>iter_until</code></a> but with the index</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri_rev"><a href="#val-iteri_rev" class="anchor"></a><code><span><span class="keyword">val</span> iteri_rev : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-iteri"><code>iteri</code></a> but starting at the end</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_list"><a href="#val-to_list" class="anchor"></a><code><span><span class="keyword">val</span> to_list : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_listi"><a href="#val-to_listi" class="anchor"></a><code><span><span class="keyword">val</span> to_listi : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> list</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_right"><a href="#val-fold_right" class="anchor"></a><code><span><span class="keyword">val</span> fold_right : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-foldi_right"><a href="#val-foldi_right" class="anchor"></a><code><span><span class="keyword">val</span> foldi_right : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_left"><a href="#val-fold_left" class="anchor"></a><code><span><span class="keyword">val</span> fold_left : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-foldi_left"><a href="#val-foldi_left" class="anchor"></a><code><span><span class="keyword">val</span> foldi_left : <span><span>(<span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_one"><a href="#val-add_one" class="anchor"></a><code><span><span class="keyword">val</span> add_one : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add a new element at the end of the vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_one"><a href="#val-remove_one" class="anchor"></a><code><span><span class="keyword">val</span> remove_one : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove the last element of the vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-remove_n"><a href="#val-remove_n" class="anchor"></a><code><span><span class="keyword">val</span> remove_n : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Remove the last n elements of the vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_array"><a href="#val-to_array" class="anchor"></a><code><span><span class="keyword">val</span> to_array : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_array"><a href="#val-of_array" class="anchor"></a><code><span><span class="keyword">val</span> of_array : <span><span><span class="type-var">'a</span> array</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure"><a href="#val-ensure" class="anchor"></a><code><span><span class="keyword">val</span> ensure : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Ensure that the vector has size at least the int by resizing if needed The value provided will be use to set the newly created values.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-keep"><a href="#val-keep" class="anchor"></a><code><span><span class="keyword">val</span> keep : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Keep only the specified number of element. If the vector was smaller, do nothing.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-resize"><a href="#val-resize" class="anchor"></a><code><span><span class="keyword">val</span> resize : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Resize the vector to the specified size. The value provided will be use to set the newly created values if relevant</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'c</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'b</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'c</span> <a href="#type-t">t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut"><a href="#val-map_mut" class="anchor"></a><code><span><span class="keyword">val</span> map_mut : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Map the function on the vector mutably by replacing each cell by the result of the function</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_mut_until"><a href="#val-map_mut_until" class="anchor"></a><code><span><span class="keyword">val</span> map_mut_until : <span><span class="label">limit</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Same as <a href="#val-map_mut"><code>map_mut</code></a> but stop at <code>limit</code>. If the vector is shorter than <code>limit</code> this is a plain <a href="#val-map_mut"><code>map_mut</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fill_all"><a href="#val-fill_all" class="anchor"></a><code><span><span class="keyword">val</span> fill_all : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Write the value in all the cells of the vector</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-insert"><a href="#val-insert" class="anchor"></a><code><span><span class="keyword">val</span> insert : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span>int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Insert an element at the specified position that may be one past the end</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq_sub"><a href="#val-to_seq_sub" class="anchor"></a><code><span><span class="keyword">val</span> to_seq_sub : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Seq/index.html#type-t">Seq.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seq"><a href="#val-to_seq" class="anchor"></a><code><span><span class="keyword">val</span> to_seq : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="../Seq/index.html#type-t">Seq.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seqi_sub"><a href="#val-to_seqi_sub" class="anchor"></a><code><span><span class="keyword">val</span> to_seqi_sub : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">pos</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span class="label">len</span>:int <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../Seq/index.html#type-t">Seq.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_seqi"><a href="#val-to_seqi" class="anchor"></a><code><span><span class="keyword">val</span> to_seqi : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span>(int * <span class="type-var">'a</span>)</span> <a href="../Seq/index.html#type-t">Seq.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Vector pretty printer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ppi"><a href="#val-ppi" class="anchor"></a><code><span><span class="keyword">val</span> ppi : <span><span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <a href="../Pp/index.html#type-document">Pp.document</a></span></code></div><div class="spec-doc"><p>Vector pretty printer that also prints the index of each element using <a href="../Pp/index.html#val-mapping"><code>Pp.mapping</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/WeakMap/index.html b/doc/html/read-dwarf/Utils/WeakMap/index.html
index 8316f6c6..8a7c70a5 100644
--- a/doc/html/read-dwarf/Utils/WeakMap/index.html
+++ b/doc/html/read-dwarf/Utils/WeakMap/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>WeakMap (read-dwarf.Utils.WeakMap)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; WeakMap</nav><h1>Module <code>Utils.WeakMap</code></h1></header><aside><p>This module provide a simple way of associated key to value without keeping them alive The key is owned by the map but the value is weakly pointed to. When the value is deleted by the GC, the binding disappears.</p><p>The value type must be heap allocated (basically not an integer or another weird type)</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>('a, 'b) t</span></code></dt><dd><p>The type of the weak map</p></dd></dl><dl><dt class="spec value" id="val-create"><a href="#val-create" class="anchor"></a><code><span class="keyword">val</span> create : int <span>&#45;&gt;</span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>The initial map</p></dd></dl><dl><dt class="spec exception" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Exists</span></code></dt></dl><dl><dt class="spec value" id="val-add"><a href="#val-add" class="anchor"></a><code><span class="keyword">val</span> add : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Add a mapping to the map. raise Exists if a is already mapped</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> <span class="type-var">'b</span></code></dt><dd><p>Retrieves a value from the table. Throws Hashtbl.Not_found if the binding do not exists</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>WeakMap (read-dwarf.Utils.WeakMap)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; WeakMap</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.WeakMap</span></code></h1><p>This module provide a simple way of associated key to value without keeping them alive The key is owned by the map but the value is weakly pointed to. When the value is deleted by the GC, the binding disappears.</p><p>The value type must be heap allocated (basically not an integer or another weird type)</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>('a, 'b) t</span></span></code></div><div class="spec-doc"><p>The type of the weak map</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span>int <span class="arrow">&#45;&gt;</span></span> <span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>The initial map</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Exists"><a href="#exception-Exists" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Exists</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'b</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Add a mapping to the map. raise Exists if a is already mapped</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'b</span></span></code></div><div class="spec-doc"><p>Retrieves a value from the table. Throws Hashtbl.Not_found if the binding do not exists</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/WeakPtr/index.html b/doc/html/read-dwarf/Utils/WeakPtr/index.html
index 5f75851f..68d89a48 100644
--- a/doc/html/read-dwarf/Utils/WeakPtr/index.html
+++ b/doc/html/read-dwarf/Utils/WeakPtr/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>WeakPtr (read-dwarf.Utils.WeakPtr)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; WeakPtr</nav><h1>Module <code>Utils.WeakPtr</code></h1></header><aside><p>This module provide a simple weak pointer that can be rendered invalid by the GC</p></aside><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> <span>'a t</span></code></dt><dd><p>The type of a weak pointer</p></dd></dl><dl><dt class="spec value" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span class="keyword">val</span> empty : unit <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Make a new empty pointer</p></dd></dl><dl><dt class="spec value" id="val-make"><a href="#val-make" class="anchor"></a><code><span class="keyword">val</span> make : <span class="type-var">'a</span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span></code></dt><dd><p>Make a new pointer and set it with the given value</p></dd></dl><dl><dt class="spec value" id="val-seto"><a href="#val-seto" class="anchor"></a><code><span class="keyword">val</span> seto : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set or clear the value inside the pointer depending of the option</p></dd></dl><dl><dt class="spec value" id="val-set"><a href="#val-set" class="anchor"></a><code><span class="keyword">val</span> set : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Set the value inside the pointer</p></dd></dl><dl><dt class="spec value" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span class="keyword">val</span> reset : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Clear the value inside the pointer</p></dd></dl><dl><dt class="spec value" id="val-geto"><a href="#val-geto" class="anchor"></a><code><span class="keyword">val</span> geto : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span><span class="type-var">'a</span> option</span></code></dt><dd><p>Retrieves the value and return None if the pointer is now empty</p></dd></dl><dl><dt class="spec exception" id="exception-Deleted"><a href="#exception-Deleted" class="anchor"></a><code><span class="keyword">exception</span> </code><code><span class="exception">Deleted</span></code></dt><dd><p>Raised when accessing and empty ptr</p></dd></dl><dl><dt class="spec value" id="val-get"><a href="#val-get" class="anchor"></a><code><span class="keyword">val</span> get : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> <span class="type-var">'a</span></code></dt><dd><p>Retrieves the value. Will raise Deleted if the value was deleted by the GC</p></dd></dl><dl><dt class="spec value" id="val-check"><a href="#val-check" class="anchor"></a><code><span class="keyword">val</span> check : <span><span class="type-var">'a</span> <a href="index.html#type-t">t</a></span> <span>&#45;&gt;</span> bool</code></dt><dd><p>Check if the pointer is filled</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>WeakPtr (read-dwarf.Utils.WeakPtr)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Utils</a> &#x00BB; WeakPtr</nav><header class="odoc-preamble"><h1>Module <code><span>Utils.WeakPtr</span></code></h1><p>This module provide a simple weak pointer that can be rendered invalid by the GC</p></header><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> <span>'a t</span></span></code></div><div class="spec-doc"><p>The type of a weak pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span>unit <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Make a new empty pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-make"><a href="#val-make" class="anchor"></a><code><span><span class="keyword">val</span> make : <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <a href="#type-t">t</a></span></span></code></div><div class="spec-doc"><p>Make a new pointer and set it with the given value</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-seto"><a href="#val-seto" class="anchor"></a><code><span><span class="keyword">val</span> seto : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span><span class="type-var">'a</span> option</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set or clear the value inside the pointer depending of the option</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Set the value inside the pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Clear the value inside the pointer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-geto"><a href="#val-geto" class="anchor"></a><code><span><span class="keyword">val</span> geto : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span><span class="type-var">'a</span> option</span></span></code></div><div class="spec-doc"><p>Retrieves the value and return None if the pointer is now empty</p></div></div><div class="odoc-spec"><div class="spec exception anchored" id="exception-Deleted"><a href="#exception-Deleted" class="anchor"></a><code><span><span class="keyword">exception</span> </span><span><span class="exception">Deleted</span></span></code></div><div class="spec-doc"><p>Raised when accessing and empty ptr</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> <span class="type-var">'a</span></span></code></div><div class="spec-doc"><p>Retrieves the value. Will raise Deleted if the value was deleted by the GC</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check"><a href="#val-check" class="anchor"></a><code><span><span class="keyword">val</span> check : <span><span><span class="type-var">'a</span> <a href="#type-t">t</a></span> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Check if the pointer is filled</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Utils/index.html b/doc/html/read-dwarf/Utils/index.html
index 31829396..ad38aeff 100644
--- a/doc/html/read-dwarf/Utils/index.html
+++ b/doc/html/read-dwarf/Utils/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Utils (read-dwarf.Utils)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Utils</nav><h1>Module <code>Utils</code></h1></header><dl><dt class="spec module" id="module-Array"><a href="#module-Array" class="anchor"></a><code><span class="keyword">module</span> <a href="Array/index.html">Array</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-BitVec"><a href="#module-BitVec" class="anchor"></a><code><span class="keyword">module</span> <a href="BitVec/index.html">BitVec</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Bits"><a href="#module-Bits" class="anchor"></a><code><span class="keyword">module</span> <a href="Bits/index.html">Bits</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-BytesSeq"><a href="#module-BytesSeq" class="anchor"></a><code><span class="keyword">module</span> <a href="BytesSeq/index.html">BytesSeq</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span class="keyword">module</span> <a href="Cache/index.html">Cache</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Cmd"><a href="#module-Cmd" class="anchor"></a><code><span class="keyword">module</span> <a href="Cmd/index.html">Cmd</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-CmdlinerHelper"><a href="#module-CmdlinerHelper" class="anchor"></a><code><span class="keyword">module</span> <a href="CmdlinerHelper/index.html">CmdlinerHelper</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Counter"><a href="#module-Counter" class="anchor"></a><code><span class="keyword">module</span> <a href="Counter/index.html">Counter</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Files"><a href="#module-Files" class="anchor"></a><code><span class="keyword">module</span> <a href="Files/index.html">Files</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-FullVec"><a href="#module-FullVec" class="anchor"></a><code><span class="keyword">module</span> <a href="FullVec/index.html">FullVec</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Fun"><a href="#module-Fun" class="anchor"></a><code><span class="keyword">module</span> <a href="Fun/index.html">Fun</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-HashVector"><a href="#module-HashVector" class="anchor"></a><code><span class="keyword">module</span> <a href="HashVector/index.html">HashVector</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-IdMap"><a href="#module-IdMap" class="anchor"></a><code><span class="keyword">module</span> <a href="IdMap/index.html">IdMap</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-IntBits"><a href="#module-IntBits" class="anchor"></a><code><span class="keyword">module</span> <a href="IntBits/index.html">IntBits</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-List"><a href="#module-List" class="anchor"></a><code><span class="keyword">module</span> <a href="List/index.html">List</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Logs"><a href="#module-Logs" class="anchor"></a><code><span class="keyword">module</span> <a href="Logs/index.html">Logs</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Option"><a href="#module-Option" class="anchor"></a><code><span class="keyword">module</span> <a href="Option/index.html">Option</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Pair"><a href="#module-Pair" class="anchor"></a><code><span class="keyword">module</span> <a href="Pair/index.html">Pair</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Pp"><a href="#module-Pp" class="anchor"></a><code><span class="keyword">module</span> <a href="Pp/index.html">Pp</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Protect"><a href="#module-Protect" class="anchor"></a><code><span class="keyword">module</span> <a href="Protect/index.html">Protect</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Raise"><a href="#module-Raise" class="anchor"></a><code><span class="keyword">module</span> <a href="Raise/index.html">Raise</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-RngMap"><a href="#module-RngMap" class="anchor"></a><code><span class="keyword">module</span> <a href="RngMap/index.html">RngMap</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Seq"><a href="#module-Seq" class="anchor"></a><code><span class="keyword">module</span> <a href="Seq/index.html">Seq</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-String"><a href="#module-String" class="anchor"></a><code><span class="keyword">module</span> <a href="String/index.html">String</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-Vec"><a href="#module-Vec" class="anchor"></a><code><span class="keyword">module</span> <a href="Vec/index.html">Vec</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-WeakMap"><a href="#module-WeakMap" class="anchor"></a><code><span class="keyword">module</span> <a href="WeakMap/index.html">WeakMap</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl><dl><dt class="spec module" id="module-WeakPtr"><a href="#module-WeakPtr" class="anchor"></a><code><span class="keyword">module</span> <a href="WeakPtr/index.html">WeakPtr</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Utils (read-dwarf.Utils)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Utils</nav><header class="odoc-preamble"><h1>Module <code><span>Utils</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec module anchored" id="module-Array"><a href="#module-Array" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Array/index.html">Array</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is for extending the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html"><code>Array</code></a> module of the standard library</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-BitVec"><a href="#module-BitVec" class="anchor"></a><code><span><span class="keyword">module</span> <a href="BitVec/index.html">BitVec</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides an interface for a bit vector of dynamic size.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Bits"><a href="#module-Bits" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Bits/index.html">Bits</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Like bytes, but for bit level manipulation. The underlying type is still bytes and thus the size has to be a multiple of 8.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-BytesSeq"><a href="#module-BytesSeq" class="anchor"></a><code><span><span class="keyword">module</span> <a href="BytesSeq/index.html">BytesSeq</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module represent a byte sub view on a <code>bytes</code> object. Contrary to <code>Bytes</code> it is a non-owning immutable view. It do not prevent the original bytes from being modified, and the changes will be propagated in the view. It is additional sugar on top of Linksem's <code>Byte_sequence_wrapper</code></p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Cache"><a href="#module-Cache" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cache/index.html">Cache</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module implement a caching system i.e a persistant structure stored on the disk.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Cmd"><a href="#module-Cmd" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Cmd/index.html">Cmd</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides high-level interaction with external processes.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-CmdlinerHelper"><a href="#module-CmdlinerHelper" class="anchor"></a><code><span><span class="keyword">module</span> <a href="CmdlinerHelper/index.html">CmdlinerHelper</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide some <code>Cmdliner</code> helper functions.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Counter"><a href="#module-Counter" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Counter/index.html">Counter</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a small counter object which is just a int reference on which <a href="Counter/index.html#val-get"><code>get</code></a> can be called to get an identifier and increment the reference</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Files"><a href="#module-Files" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Files/index.html">Files</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provides simplified file management and some channel interaction function.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-FullVec"><a href="#module-FullVec" class="anchor"></a><code><span><span class="keyword">module</span> <a href="FullVec/index.html">FullVec</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A full vector is a vector in which all non-negative integer are bound.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Fun"><a href="#module-Fun" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Fun/index.html">Fun</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>More functional combinator. This module extends the base OCaml API of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Fun.html"><code>Fun</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-HashVector"><a href="#module-HashVector" class="anchor"></a><code><span><span class="keyword">module</span> <a href="HashVector/index.html">HashVector</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>An hash vector allow a vector to behave as hash map indexed by small integers. It is hash map with the identity hash function.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-IdMap"><a href="#module-IdMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IdMap/index.html">IdMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>An IdMap is a map that associate an id to each key (and thus to each value).</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-IntBits"><a href="#module-IntBits" class="anchor"></a><code><span><span class="keyword">module</span> <a href="IntBits/index.html">IntBits</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Manipulate an int as bitfield of size 31 or 63.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-List"><a href="#module-List" class="anchor"></a><code><span><span class="keyword">module</span> <a href="List/index.html">List</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Extension of the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html"><code>List</code></a> module of the standard library.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Logs"><a href="#module-Logs" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Logs/index.html">Logs</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a logging system for each module.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Option"><a href="#module-Option" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Option/index.html">Option</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module extends the base OCaml API of <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Option.html"><code>Option</code></a>.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Pair"><a href="#module-Pair" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Pair/index.html">Pair</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module contain random utility functions dealing with pairs</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Pp"><a href="#module-Pp" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Pp/index.html">Pp</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide all pretty printing functionality. It's main goal is not directly handle the output but to handle how to layout complex data structure in a text format.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Protect"><a href="#module-Protect" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Protect/index.html">Protect</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide try-with-finally kind of exception handling.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Raise"><a href="#module-Raise" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Raise/index.html">Raise</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide convenience facilities to raise exception or other exception management</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-RngMap"><a href="#module-RngMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="RngMap/index.html">RngMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>A module giving a map indexing data with address ranges and providing access to quick access to data corresponding to any value in-between.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Seq"><a href="#module-Seq" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Seq/index.html">Seq</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module is for extending the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/Seq.html">Seq</a> module of the standard library</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-String"><a href="#module-String" class="anchor"></a><code><span><span class="keyword">module</span> <a href="String/index.html">String</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Extension of the <a href="https://caml.inria.fr/pub/docs/manual-ocaml/libref/String.html"><code>String</code></a> module of the standard library.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Sym"><a href="#module-Sym" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Sym/index.html">Sym</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Vec"><a href="#module-Vec" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Vec/index.html">Vec</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a resizable array. It is a rename of Res.array with added features</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-WeakMap"><a href="#module-WeakMap" class="anchor"></a><code><span><span class="keyword">module</span> <a href="WeakMap/index.html">WeakMap</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a simple way of associated key to value without keeping them alive The key is owned by the map but the value is weakly pointed to. When the value is deleted by the GC, the binding disappears.</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-WeakPtr"><a href="#module-WeakPtr" class="anchor"></a><code><span><span class="keyword">module</span> <a href="WeakPtr/index.html">WeakPtr</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>This module provide a simple weak pointer that can be rendered invalid by the GC</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/CheckContext/index.html b/doc/html/read-dwarf/Z3/CheckContext/index.html
index 83e0ead6..b990d59b 100644
--- a/doc/html/read-dwarf/Z3/CheckContext/index.html
+++ b/doc/html/read-dwarf/Z3/CheckContext/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CheckContext (read-dwarf.Z3.CheckContext)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; CheckContext</nav><h1>Module <code>Z3.CheckContext</code></h1></header><dl><dt class="spec value" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span class="keyword">val</span> counter : <a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></code></dt><dt class="spec value" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span class="keyword">val</span> openc : unit <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-num"><a href="#val-num" class="anchor"></a><code><span class="keyword">val</span> num : unit <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span class="keyword">val</span> closec : unit <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>CheckContext (read-dwarf.Z3.CheckContext)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; CheckContext</nav><header class="odoc-preamble"><h1>Module <code><span>Z3.CheckContext</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span><span class="keyword">val</span> counter : <a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span><span class="keyword">val</span> openc : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-num"><a href="#val-num" class="anchor"></a><code><span><span class="keyword">val</span> num : <span>unit <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span><span class="keyword">val</span> closec : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/ContextCounter/argument-1-S/index.html b/doc/html/read-dwarf/Z3/ContextCounter/argument-1-S/index.html
index 293b4ab8..565b842c 100644
--- a/doc/html/read-dwarf/Z3/ContextCounter/argument-1-S/index.html
+++ b/doc/html/read-dwarf/Z3/ContextCounter/argument-1-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-S (read-dwarf.Z3.ContextCounter.1-S)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Z3</a> &#x00BB; <a href="../index.html">ContextCounter</a> &#x00BB; 1-S</nav><h1>Parameter <code>ContextCounter.1-S</code></h1></header><dl><dt class="spec value" id="val-str"><a href="#val-str" class="anchor"></a><code><span class="keyword">val</span> str : string</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Z3.ContextCounter.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Z3</a> &#x00BB; <a href="../index.html">ContextCounter</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Parameter <code><span>ContextCounter.S</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-str"><a href="#val-str" class="anchor"></a><code><span><span class="keyword">val</span> str : string</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/ContextCounter/index.html b/doc/html/read-dwarf/Z3/ContextCounter/index.html
index 36935686..09086b01 100644
--- a/doc/html/read-dwarf/Z3/ContextCounter/index.html
+++ b/doc/html/read-dwarf/Z3/ContextCounter/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ContextCounter (read-dwarf.Z3.ContextCounter)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; ContextCounter</nav><h1>Module <code>Z3.ContextCounter</code></h1><p>Module for handling a context numbering scheme automatically.</p><p>To use it do: <code>module Whatever = ContextCounter(struct let str= &quot;name here&quot; end)</code> Then you can use it with <code>Whatever.openc ()</code> and <code>Whatever.closec ()</code>. You can get the current instance number with <code>Whatever.num()</code> at any time.</p></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-S/index.html">S</a> : <a href="../../Utils/Logs/index.html#module-type-String">Utils.Logs.String</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec value" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span class="keyword">val</span> counter : <a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></code></dt><dt class="spec value" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span class="keyword">val</span> openc : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Open a new context of that <code>ContextCounter</code>. Ensure the server is started</p></dd></dl><dl><dt class="spec value" id="val-num"><a href="#val-num" class="anchor"></a><code><span class="keyword">val</span> num : unit <span>&#45;&gt;</span> int</code></dt><dd><p>Get the current context number</p></dd></dl><dl><dt class="spec value" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span class="keyword">val</span> closec : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Close a context opened with <a href="index.html#val-openc"><code>openc</code></a>. Assert that the current context was indeed opened by this module</p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>ContextCounter (read-dwarf.Z3.ContextCounter)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; ContextCounter</nav><header class="odoc-preamble"><h1>Module <code><span>Z3.ContextCounter</span></code></h1><p>Module for handling a context numbering scheme automatically.</p><p>To use it do: <code>module Whatever = ContextCounter(struct let str= &quot;name here&quot; end)</code> Then you can use it with <code>Whatever.openc ()</code> and <code>Whatever.closec ()</code>. You can get the current instance number with <code>Whatever.num()</code> at any time.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-S"><a href="#argument-1-S" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-S/index.html">S</a></span><span> : <a href="../../Utils/Logs/module-type-String/index.html">Utils.Logs.String</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec value anchored" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span><span class="keyword">val</span> counter : <a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span><span class="keyword">val</span> openc : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Open a new context of that <code>ContextCounter</code>. Ensure the server is started</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-num"><a href="#val-num" class="anchor"></a><code><span><span class="keyword">val</span> num : <span>unit <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Get the current context number</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span><span class="keyword">val</span> closec : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Close a context opened with <a href="#val-openc"><code>openc</code></a>. Assert that the current context was indeed opened by this module</p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/Make/argument-1-Var/index.html b/doc/html/read-dwarf/Z3/Make/argument-1-Var/index.html
index 99665999..27eb425d 100644
--- a/doc/html/read-dwarf/Z3/Make/argument-1-Var/index.html
+++ b/doc/html/read-dwarf/Z3/Make/argument-1-Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>1-Var (read-dwarf.Z3.Make.1-Var)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Z3</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; 1-Var</nav><h1>Parameter <code>Make.1-Var</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../Exp/index.html#module-type-Var">Exp.Var</a></code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of variables</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality predicate that will be passed to expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></dd></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../../Exp/index.html#type-ty">Exp.ty</a></code></dt><dd><p>Get the type of the variable</p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Hashing function to store variable in <code>Hashtbl</code>s. Must be compatible with <a href="index.html#val-equal"><code>equal</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Parser from a string. Must be the inverse of <a href="index.html#val-pp"><code>pp</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Z3.Make.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../../index.html">Index</a> &#x00BB; <a href="../../../index.html">read-dwarf</a> &#x00BB; <a href="../../index.html">Z3</a> &#x00BB; <a href="../index.html">Make</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Parameter <code><span>Make.Var</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../../Exp/module-type-Var/index.html">Exp.Var</a></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Equality predicate that will be passed to expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../../Exp/index.html#type-ty">Exp.ty</a></span></code></div><div class="spec-doc"><p>Get the type of the variable</p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Hashing function to store variable in <code>Hashtbl</code>s. Must be compatible with <a href="#val-equal"><code>equal</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Parser from a string. Must be the inverse of <a href="#val-pp"><code>pp</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/Make/index.html b/doc/html/read-dwarf/Z3/Make/index.html
index 88920fd3..c4df3e7f 100644
--- a/doc/html/read-dwarf/Z3/Make/index.html
+++ b/doc/html/read-dwarf/Z3/Make/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Z3.Make)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; Make</nav><h1>Module <code>Z3.Make</code></h1><nav class="toc"><ul><li><a href="#variable-declarations">Variable declarations</a></li><li><a href="#simplification">Simplification</a></li><li><a href="#smt-checking">SMT checking</a></li><li><a href="#nocontext">Context less operation</a></li></ul></nav></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-Var/index.html">Var</a> : <a href="../index.html#module-type-Var">Var</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code><code> = <a href="argument-1-Var/index.html#type-t">Var.t</a></code></dt></dl><section><header><h2 id="variable-declarations"><a href="#variable-declarations" class="anchor"></a>Variable declarations</h2><p>The goal of those operation is to declare variables with their types to the SMT solver. The <a href="Htbl/index.html"><code>Htbl</code></a> allow to declare every variable only once.</p></header><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dd><p>The type of expression on which SMT operation are made</p></dd></dl><dl><dt class="spec module" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span class="keyword">module</span> Htbl : Stdlib.Hashtbl.S <span class="keyword">with</span> <span class="keyword">type</span> <a href="index.html#module-Htbl">Htbl</a>.key = <a href="index.html#type-var">var</a></code></dt><dd><p>Hash tables over variables</p></dd></dl><dl><dt class="spec value" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span class="keyword">val</span> declare_var_always : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Declare the variable regardless of whether it has already been declared</p></dd></dl><dl><dt class="spec value" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span class="keyword">val</span> declare_var : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Declare the variable if it's not in <code>declared</code>. In that case, it also add it to <code>declared</code></p></dd></dl><dl><dt class="spec value" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span class="keyword">val</span> declare_vars : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Declare all not yet declared the variable in the expression, then add them to <code>declared</code></p></dd></dl></section><section><header><h2 id="simplification"><a href="#simplification" class="anchor"></a>Simplification</h2></header><dl><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Simplify the expression in the current context. All the variable must already have been declared.</p></dd></dl><dl><dt class="spec value" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span class="keyword">val</span> simplify_decl : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Literally just <a href="index.html#val-declare_vars"><code>declare_vars</code></a> then <a href="index.html#val-simplify"><code>simplify</code></a></p></dd></dl></section><section><header><h2 id="smt-checking"><a href="#smt-checking" class="anchor"></a>SMT checking</h2></header><dl><dt class="spec value" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span class="keyword">val</span> send_assert : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Assert that expression in the current context</p></dd></dl><dl><dt class="spec value" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span class="keyword">val</span> send_assert_decl : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Literally just <a href="index.html#val-declare_vars"><code>declare_vars</code></a> then <a href="index.html#val-send_assert"><code>send_assert</code></a></p></dd></dl><dl><dt class="spec value" id="val-check"><a href="#val-check" class="anchor"></a><code><span class="keyword">val</span> check : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if this expression is always true in the current context. <code>None</code> is returned when the SMT solver didn't know</p></dd></dl><dl><dt class="spec value" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span class="keyword">val</span> check_sat : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if this expression is true on at least one assignment of the variables.ioserver <code>None</code> is returned when the SMT solver didn't know</p></dd></dl><dl><dt class="spec value" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span class="keyword">val</span> check_both : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if this expression is always true of always false. <code>None</code> is returned if neither can be proven.</p><p>This results in two calls to the SMT solver. one with <a href="index.html#val-check"><code>check</code></a> and one with <a href="index.html#val-check_sat"><code>check_sat</code></a></p></dd></dl></section><section><header><h2 id="nocontext"><a href="#nocontext" class="anchor"></a>Context less operation</h2><p>Those operations do not require a context to operate. They require not setup and tear-down. They are standalone and fully automated.</p><p>On the other hand doing multiple one of those in sequence if much less efficient than using properly the functions of previous section.</p></header><dl><dt class="spec value" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span class="keyword">val</span> simplify_full : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Do a standalone simplification in it's own context. Do not need anything to be already declared or any context to be opened.</p></dd></dl><dl><dt class="spec value" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span class="keyword">val</span> check_full : <span>?&#8288;hyps:<span><a href="index.html#type-exp">exp</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Do a standalone check of whether the expression is implied by the list of hypothesis.</p></dd></dl><dl><dt class="spec value" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span class="keyword">val</span> check_sat_full : <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Do a standalone check of whether the set of assertion is sat</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (read-dwarf.Z3.Make)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; Make</nav><header class="odoc-preamble"><h1>Module <code><span>Z3.Make</span></code></h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#parameters">Parameters</a></li><li><a href="#signature">Signature</a></li><li><a href="#variable-declarations">Variable declarations</a></li><li><a href="#simplification">Simplification</a></li><li><a href="#smt-checking">SMT checking</a></li><li><a href="#nocontext">Context less operation</a></li></ul></nav></div><div class="odoc-content"><h2 id="parameters"><a href="#parameters" class="anchor"></a>Parameters</h2><div class="odoc-spec"><div class="spec parameter anchored" id="argument-1-Var"><a href="#argument-1-Var" class="anchor"></a><code><span><span class="keyword">module</span> </span><span><a href="argument-1-Var/index.html">Var</a></span><span> : <a href="../module-type-Var/index.html">Var</a></span></code></div></div><h2 id="signature"><a href="#signature" class="anchor"></a>Signature</h2><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span><span> = <a href="argument-1-Var/index.html#type-t">Var.t</a></span></code></div></div><h2 id="variable-declarations"><a href="#variable-declarations" class="anchor"></a>Variable declarations</h2><p>The goal of those operation is to declare variables with their types to the SMT solver. The <a href="Htbl/index.html"><code>Htbl</code></a> allow to declare every variable only once.</p><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div><div class="spec-doc"><p>The type of expression on which SMT operation are made</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span><span class="keyword">module</span> Htbl</span><span> : <span class="xref-unresolved">Stdlib</span>.Hashtbl.S <span class="keyword">with</span> <span><span class="keyword">type</span> <span class="xref-unresolved">key</span> = <span class="xref-unresolved">var</span></span></span></code></div><div class="spec-doc"><p>Hash tables over variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span><span class="keyword">val</span> declare_var_always : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Declare the variable regardless of whether it has already been declared</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span><span class="keyword">val</span> declare_var : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Declare the variable if it's not in <code>declared</code>. In that case, it also add it to <code>declared</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span><span class="keyword">val</span> declare_vars : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Declare all not yet declared the variable in the expression, then add them to <code>declared</code></p></div></div><h2 id="simplification"><a href="#simplification" class="anchor"></a>Simplification</h2><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Simplify the expression in the current context. All the variable must already have been declared.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_decl : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Literally just <a href="#val-declare_vars"><code>declare_vars</code></a> then <a href="#val-simplify"><code>simplify</code></a></p></div></div><h2 id="smt-checking"><a href="#smt-checking" class="anchor"></a>SMT checking</h2><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span><span class="keyword">val</span> send_assert : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Assert that expression in the current context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span><span class="keyword">val</span> send_assert_decl : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Literally just <a href="#val-declare_vars"><code>declare_vars</code></a> then <a href="#val-send_assert"><code>send_assert</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check"><a href="#val-check" class="anchor"></a><code><span><span class="keyword">val</span> check : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if this expression is always true in the current context. <code>None</code> is returned when the SMT solver didn't know</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span><span class="keyword">val</span> check_sat : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if this expression is true on at least one assignment of the variables.ioserver <code>None</code> is returned when the SMT solver didn't know</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span><span class="keyword">val</span> check_both : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if this expression is always true of always false. <code>None</code> is returned if neither can be proven.</p><p>This results in two calls to the SMT solver. one with <a href="#val-check"><code>check</code></a> and one with <a href="#val-check_sat"><code>check_sat</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms"><a href="#val-simplify_subterms" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_decl"><a href="#val-simplify_subterms_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_decl : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><h2 id="nocontext"><a href="#nocontext" class="anchor"></a>Context less operation</h2><p>Those operations do not require a context to operate. They require not setup and tear-down. They are standalone and fully automated.</p><p>On the other hand doing multiple one of those in sequence if much less efficient than using properly the functions of previous section.</p><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_full : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Do a standalone simplification in it's own context. Do not need anything to be already declared or any context to be opened.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span><span class="keyword">val</span> check_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Do a standalone check of whether the expression is implied by the list of hypothesis.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span><span class="keyword">val</span> check_sat_full : <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Do a standalone check of whether the set of assertion is sat</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_full"><a href="#val-simplify_subterms_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/SimpContext/index.html b/doc/html/read-dwarf/Z3/SimpContext/index.html
index 4a31f6b4..eb59a8e5 100644
--- a/doc/html/read-dwarf/Z3/SimpContext/index.html
+++ b/doc/html/read-dwarf/Z3/SimpContext/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SimpContext (read-dwarf.Z3.SimpContext)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; SimpContext</nav><h1>Module <code>Z3.SimpContext</code></h1></header><dl><dt class="spec value" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span class="keyword">val</span> counter : <a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></code></dt><dt class="spec value" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span class="keyword">val</span> openc : unit <span>&#45;&gt;</span> unit</code></dt><dt class="spec value" id="val-num"><a href="#val-num" class="anchor"></a><code><span class="keyword">val</span> num : unit <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span class="keyword">val</span> closec : unit <span>&#45;&gt;</span> unit</code></dt></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>SimpContext (read-dwarf.Z3.SimpContext)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; SimpContext</nav><header class="odoc-preamble"><h1>Module <code><span>Z3.SimpContext</span></code></h1></header><div class="odoc-content"><div class="odoc-spec"><div class="spec value anchored" id="val-counter"><a href="#val-counter" class="anchor"></a><code><span><span class="keyword">val</span> counter : <a href="../../Utils/Counter/index.html#type-t">Utils.Counter.t</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-openc"><a href="#val-openc" class="anchor"></a><code><span><span class="keyword">val</span> openc : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-num"><a href="#val-num" class="anchor"></a><code><span><span class="keyword">val</span> num : <span>unit <span class="arrow">&#45;&gt;</span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-closec"><a href="#val-closec" class="anchor"></a><code><span><span class="keyword">val</span> closec : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/index.html b/doc/html/read-dwarf/Z3/index.html
index 79df9fe7..6cc568d3 100644
--- a/doc/html/read-dwarf/Z3/index.html
+++ b/doc/html/read-dwarf/Z3/index.html
@@ -1,2 +1,12 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3 (read-dwarf.Z3)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">read-dwarf</a> &#x00BB; Z3</nav><h1>Module <code>Z3</code></h1><p>This module handles a Z3 server</p><p>For high level usage, call <a href="index.html#val-start"><code>start</code></a> or <a href="index.html#val-ensure_started"><code>ensure_started</code></a> then instantiate the <a href="Make/index.html"><code>Make</code></a> functor and use operation in the section about <a href="module-type-S/index.html#nocontext"><span>Context less operation</span></a>:</p><p>For a more medium level usage, you may want to manage your context manually before making requests. The best way of doing that is by using a <a href="ContextCounter/index.html"><code>ContextCounter</code></a>.</p><p>Once you are in the correct context, you can use your instantiated version of <a href="Make/index.html"><code>Make</code></a> to do operations such as: <a href="module-type-S/index.html#val-declare_var"><code>S.declare_var</code></a> or <a href="module-type-S/index.html#val-send_assert"><code>S.send_assert</code></a> to build your context, and then <a href="module-type-S/index.html#val-simplify"><code>S.simplify</code></a>, <a href="module-type-S/index.html#val-check"><code>S.check</code></a> of <a href="module-type-S/index.html#val-check_sat"><code>S.check_sat</code></a>.</p><p>For low-level details (All function in the first two section of this module should probably be reserved to those who understand the implementation)</p><p>The module keeps Z3 as a child process and communicates through pipes using <a href="../Utils/Cmd/IOServer/index.html"><code>Cmd.IOServer</code></a>.</p><p><a href="index.html#val-start"><code>start</code></a> sends the introduction in <code>intro.smt2</code> to Z3 so that it is available in any context. SMT answer are parsed from the pipe with <a href="../Utils/Files/index.html#val-input_sexp"><code>Files.input_sexp</code></a>. If the wrong number of answer is expected, the system will just deadlock.</p><nav class="toc"><ul><li><a href="#raw-server-management">Raw server management</a></li><li><a href="#request-and-answer-management">Request and answer management</a></li><li><a href="#full-startup-and-shutdown">Full startup and shutdown</a></li><li><a href="#context">Context management</a></li><li><a href="#high-level-interaction">High level interaction</a></li></ul></nav></header><section><header><h2 id="raw-server-management"><a href="#raw-server-management" class="anchor"></a>Raw server management</h2></header><dl><dt class="spec value" id="val-z3_trace"><a href="#val-z3_trace" class="anchor"></a><code><span class="keyword">val</span> z3_trace : bool</code></dt><dd><p>A boolean enabling context tracing (For better error messages)</p></dd></dl><dl><dt class="spec type" id="type-context_elem"><a href="#type-context_elem" class="anchor"></a><code><span class="keyword">type</span> context_elem</code><code> = </code><code>{</code><table class="record"><tr id="type-context_elem.name" class="anchored"><td class="def field"><a href="#type-context_elem.name" class="anchor"></a><code>name : string;</code></td></tr><tr id="type-context_elem.num" class="anchored"><td class="def field"><a href="#type-context_elem.num" class="anchor"></a><code><span class="keyword">mutable</span> num : int;</code></td></tr></table><code>}</code></dt><dd><p>An element of the context stack. It has a name and a declaration number.</p><p>The declaration number is incremented at each declaration in the context.</p></dd></dl><dl><dt class="spec type" id="type-context"><a href="#type-context" class="anchor"></a><code><span class="keyword">type</span> context</code><code> = <span><a href="index.html#type-context_elem">context_elem</a> list</span></code></dt><dd><p>The type of a SMT context stack</p></dd></dl><dl><dt class="spec value" id="val-start_context"><a href="#val-start_context" class="anchor"></a><code><span class="keyword">val</span> start_context : <a href="index.html#type-context">context</a></code></dt><dd><p>The starting context</p></dd></dl><dl><dt class="spec value" id="val-context_elem_to_string"><a href="#val-context_elem_to_string" class="anchor"></a><code><span class="keyword">val</span> context_elem_to_string : <a href="index.html#type-context_elem">context_elem</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Give a string representation of a <a href="index.html#type-context_elem"><code>context_elem</code></a></p></dd></dl><dl><dt class="spec type" id="type-server"><a href="#type-server" class="anchor"></a><code><span class="keyword">type</span> server</code><code> = </code><code>{</code><table class="record"><tr id="type-server.ioserver" class="anchored"><td class="def field"><a href="#type-server.ioserver" class="anchor"></a><code>ioserver : <a href="../Utils/Cmd/IOServer/index.html#type-t">Utils.Cmd.IOServer.t</a>;</code></td></tr><tr id="type-server.config" class="anchored"><td class="def field"><a href="#type-server.config" class="anchor"></a><code>config : <a href="../Config__File/Z3/index.html#type-t">Config.File.Z3.t</a>;</code></td></tr><tr id="type-server.context" class="anchored"><td class="def field"><a href="#type-server.context" class="anchor"></a><code><span class="keyword">mutable</span> context : <a href="index.html#type-context">context</a>;</code></td></tr></table><code>}</code></dt><dd><p>The type of a Z3 server</p></dd></dl><dl><dt class="spec value" id="val-server"><a href="#val-server" class="anchor"></a><code><span class="keyword">val</span> server : <span><span><a href="index.html#type-server">server</a> option</span> Stdlib.ref</span></code></dt><dd><p>The global Z3 server</p></dd></dl><dl><dt class="spec value" id="val-get_server"><a href="#val-get_server" class="anchor"></a><code><span class="keyword">val</span> get_server : unit <span>&#45;&gt;</span> <a href="index.html#type-server">server</a></code></dt><dd><p>Assume the server is started and returns it.</p></dd></dl><dl><dt class="spec value" id="val-raw_start"><a href="#val-raw_start" class="anchor"></a><code><span class="keyword">val</span> raw_start : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Start Z3 without any checks and without sending intro or pushing</p></dd></dl><dl><dt class="spec value" id="val-raw_stop"><a href="#val-raw_stop" class="anchor"></a><code><span class="keyword">val</span> raw_stop : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop Z3 without asking politely</p></dd></dl><dl><dt class="spec value" id="val-get_context_string"><a href="#val-get_context_string" class="anchor"></a><code><span class="keyword">val</span> get_context_string : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Give a string representation of the current context for error reporting</p></dd></dl><dl><dt class="spec value" id="val-incr_context"><a href="#val-incr_context" class="anchor"></a><code><span class="keyword">val</span> incr_context : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Increment the declaration number of the top <a href="index.html#type-context_elem"><code>context_elem</code></a>.</p></dd></dl></section><section><header><h2 id="request-and-answer-management"><a href="#request-and-answer-management" class="anchor"></a>Request and answer management</h2><p>This section handle raw and less raw direct interaction with the Z3 server.</p><p>The <code>send_*</code> function are for sending information to the server with a server handle. This avoided checking if the server is open at each declaration.</p><p>The <code>read_*</code> functions are the same the other way around.</p><p>The <a href="index.html#val-request"><code>request</code></a> and <a href="index.html#val-command"><code>command</code></a> are high level versions</p></header><dl><dt class="spec value" id="val-send_string"><a href="#val-send_string" class="anchor"></a><code><span class="keyword">val</span> send_string : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dd><p>Send a string to the server and increment the declaration number in the context</p></dd></dl><dl><dt class="spec value" id="val-send_smt"><a href="#val-send_smt" class="anchor"></a><code><span class="keyword">val</span> send_smt : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> <span>?&#8288;ppv:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Send a smt statement to the server and increment the declaration number in the context</p></dd></dl><dl><dt class="spec value" id="val-read_string"><a href="#val-read_string" class="anchor"></a><code><span class="keyword">val</span> read_string : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Read a string from the server (A Z3 answer is always a valid sexp)</p></dd></dl><dl><dt class="spec value" id="val-read_smt_ans"><a href="#val-read_smt_ans" class="anchor"></a><code><span class="keyword">val</span> read_smt_ans : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a></code></dt><dd><p>Read a <code>smt_ans</code> from the server</p></dd></dl><dl><dt class="spec value" id="val-request"><a href="#val-request" class="anchor"></a><code><span class="keyword">val</span> request : <span>?&#8288;ppv:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> <a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a></code></dt><dd><p>Make a request to the server and expect an answer. Will hang if there is no answer</p></dd></dl><dl><dt class="spec value" id="val-command"><a href="#val-command" class="anchor"></a><code><span class="keyword">val</span> command : <span>?&#8288;ppv:<span>(<span class="type-var">'a</span> <span>&#45;&gt;</span> <a href="../Utils/index.html#module-Pp">Utils.Pp</a>.document)</span></span> <span>&#45;&gt;</span> <span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span>&#45;&gt;</span> unit</code></dt><dd><p>Send a command or a declaration to the server</p></dd></dl><dl><dt class="spec value" id="val-expect_version"><a href="#val-expect_version" class="anchor"></a><code><span class="keyword">val</span> expect_version : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a> <span>&#45;&gt;</span> string</code></dt><dd><p>Expect a version answer and fails if it is not the case</p></dd></dl><dl><dt class="spec value" id="val-expect_exp"><a href="#val-expect_exp" class="anchor"></a><code><span class="keyword">val</span> expect_exp : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a> <span>&#45;&gt;</span> <a href="../Ast/index.html#type-rexp">Ast.rexp</a></code></dt><dd><p>Expect an expression answer and fails if it is not the case</p></dd></dl><dl><dt class="spec value" id="val-get_version"><a href="#val-get_version" class="anchor"></a><code><span class="keyword">val</span> get_version : unit <span>&#45;&gt;</span> string</code></dt><dd><p>Get the Z3 version string</p></dd></dl><dl><dt class="spec value" id="val-is_context_sat"><a href="#val-is_context_sat" class="anchor"></a><code><span class="keyword">val</span> is_context_sat : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if the current context is sat</p></dd></dl></section><section><header><h2 id="full-startup-and-shutdown"><a href="#full-startup-and-shutdown" class="anchor"></a>Full startup and shutdown</h2></header><dl><dt class="spec value" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span class="keyword">val</span> stop : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Stop the Z3 server properly</p></dd></dl><dl><dt class="spec value" id="val-ensure_stopped"><a href="#val-ensure_stopped" class="anchor"></a><code><span class="keyword">val</span> ensure_stopped : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Call <a href="index.html#val-stop"><code>stop</code></a> if the server wasn't stopped</p></dd></dl><dl><dt class="spec value" id="val-start"><a href="#val-start" class="anchor"></a><code><span class="keyword">val</span> start : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Start the Z3 Server and setup the intro</p></dd></dl><dl><dt class="spec value" id="val-ensure_started"><a href="#val-ensure_started" class="anchor"></a><code><span class="keyword">val</span> ensure_started : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Call <a href="index.html#val-start"><code>start</code></a> if the server wasn't started</p></dd></dl><dl><dt class="spec value" id="val-ensure_started_get"><a href="#val-ensure_started_get" class="anchor"></a><code><span class="keyword">val</span> ensure_started_get : unit <span>&#45;&gt;</span> <a href="index.html#type-server">server</a></code></dt><dd><p>Call <a href="index.html#val-start"><code>start</code></a> if the server wasn't started, then return the server</p></dd></dl><dl><dt class="spec value" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span class="keyword">val</span> reset : unit <span>&#45;&gt;</span> unit</code></dt><dd><p>Reset the Z3 server, forgetting everything. Useful for resetting in a test failure context, but probably shouldn't be used in normal operations</p></dd></dl></section><section><header><h2 id="context"><a href="#context" class="anchor"></a>Context management</h2><p>Z3 contexts are managed in a stack way.</p><p>There are implemented using <code>(push)</code> and <code>(pop)</code> on the Z3 side.</p><p><a href="index.html#val-open_context"><code>open_context</code></a> can open a named context. However if it is expected to open a given context name multiple times, using <a href="ContextCounter/index.html"><code>ContextCounter</code></a> is advised.</p></header><dl><dt class="spec value" id="val-open_context"><a href="#val-open_context" class="anchor"></a><code><span class="keyword">val</span> open_context : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> string <span>&#45;&gt;</span> unit</code></dt><dd><p>Open a new context with a name.</p></dd></dl><dl><dt class="spec value" id="val-close_context"><a href="#val-close_context" class="anchor"></a><code><span class="keyword">val</span> close_context : <a href="index.html#type-server">server</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Closes current context of the server</p></dd></dl><dl><dt class="spec module" id="module-ContextCounter"><a href="#module-ContextCounter" class="anchor"></a><code><span class="keyword">module</span> <a href="ContextCounter/index.html">ContextCounter</a> : <span class="keyword">functor</span> (<a href="ContextCounter/argument-1-S/index.html">S</a> : <a href="../Utils/Logs/index.html#module-type-String">Utils.Logs.String</a>) <span>&#45;&gt;</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>Module for handling a context numbering scheme automatically.</p></dd></dl></section><section><header><h2 id="high-level-interaction"><a href="#high-level-interaction" class="anchor"></a>High level interaction</h2><p>This section provide functor that can be instantiated to get easy to use SMT functionality</p></header><dl><dt class="spec module-type" id="module-type-Var"><a href="#module-type-Var" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Var/index.html">Var</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></dt><dd><p>The functors in this section require a bit more support from variable than plain <a href="../Exp/module-type-Var/index.html"><code>Exp.Var</code></a></p></dd></dl><div class="spec module-type" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a> = <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-SimpContext"><a href="#module-SimpContext" class="anchor"></a><code><span class="keyword">module</span> <a href="SimpContext/index.html">SimpContext</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-CheckContext"><a href="#module-CheckContext" class="anchor"></a><code><span class="keyword">module</span> <a href="CheckContext/index.html">CheckContext</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><div class="spec module" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span class="keyword">module</span> <a href="Make/index.html">Make</a> : <span class="keyword">functor</span> (<a href="Make/argument-1-Var/index.html">Var</a> : <a href="index.html#module-type-Var">Var</a>) <span>&#45;&gt;</span> <a href="index.html#module-type-S">S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="Make/index.html#type-var">var</a> = <a href="Make/argument-1-Var/index.html#type-t">Var.t</a></code></div></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Z3 (read-dwarf.Z3)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../index.html">Index</a> &#x00BB; <a href="../index.html">read-dwarf</a> &#x00BB; Z3</nav><header class="odoc-preamble"><h1>Module <code><span>Z3</span></code></h1><p>This module handles a Z3 server</p><p>For high level usage, call <a href="#val-start"><code>start</code></a> or <a href="#val-ensure_started"><code>ensure_started</code></a> then instantiate the <a href="Make/index.html"><code>Make</code></a> functor and use operation in the section about <a href="module-type-S/index.html#nocontext" title="nocontext">Context less operation</a>:</p><p>For a more medium level usage, you may want to manage your context manually before making requests. The best way of doing that is by using a <a href="ContextCounter/index.html"><code>ContextCounter</code></a>.</p><p>Once you are in the correct context, you can use your instantiated version of <a href="Make/index.html"><code>Make</code></a> to do operations such as: <a href="module-type-S/index.html#val-declare_var"><code>S.declare_var</code></a> or <a href="module-type-S/index.html#val-send_assert"><code>S.send_assert</code></a> to build your context, and then <a href="module-type-S/index.html#val-simplify"><code>S.simplify</code></a>, <a href="module-type-S/index.html#val-check"><code>S.check</code></a> of <a href="module-type-S/index.html#val-check_sat"><code>S.check_sat</code></a>.</p><p>For low-level details (All function in the first two section of this module should probably be reserved to those who understand the implementation)</p><p>The module keeps Z3 as a child process and communicates through pipes using <a href="../Utils/Cmd/IOServer/index.html"><code>Utils.Cmd.IOServer</code></a>.</p><p><a href="#val-start"><code>start</code></a> sends the introduction in <code>intro.smt2</code> to Z3 so that it is available in any context. SMT answer are parsed from the pipe with <a href="../Utils/Files/index.html#val-input_sexp"><code>Utils.Files.input_sexp</code></a>. If the wrong number of answer is expected, the system will just deadlock.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#raw-server-management">Raw server management</a></li><li><a href="#request-and-answer-management">Request and answer management</a></li><li><a href="#full-startup-and-shutdown">Full startup and shutdown</a></li><li><a href="#context">Context management</a></li><li><a href="#high-level-interaction">High level interaction</a></li></ul></nav></div><div class="odoc-content"><h2 id="raw-server-management"><a href="#raw-server-management" class="anchor"></a>Raw server management</h2><div class="odoc-spec"><div class="spec value anchored" id="val-z3_trace"><a href="#val-z3_trace" class="anchor"></a><code><span><span class="keyword">val</span> z3_trace : bool</span></code></div><div class="spec-doc"><p>A boolean enabling context tracing (For better error messages)</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-context_elem"><a href="#type-context_elem" class="anchor"></a><code><span><span class="keyword">type</span> context_elem</span><span> = </span><span>{</span></code><ol><li id="type-context_elem.name" class="def record field anchored"><a href="#type-context_elem.name" class="anchor"></a><code><span>name : string;</span></code></li><li id="type-context_elem.num" class="def record field anchored"><a href="#type-context_elem.num" class="anchor"></a><code><span><span class="keyword">mutable</span> num : int;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>An element of the context stack. It has a name and a declaration number.</p><p>The declaration number is incremented at each declaration in the context.</p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-context"><a href="#type-context" class="anchor"></a><code><span><span class="keyword">type</span> context</span><span> = <span><a href="#type-context_elem">context_elem</a> list</span></span></code></div><div class="spec-doc"><p>The type of a SMT context stack</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start_context"><a href="#val-start_context" class="anchor"></a><code><span><span class="keyword">val</span> start_context : <a href="#type-context">context</a></span></code></div><div class="spec-doc"><p>The starting context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-context_elem_to_string"><a href="#val-context_elem_to_string" class="anchor"></a><code><span><span class="keyword">val</span> context_elem_to_string : <span><a href="#type-context_elem">context_elem</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Give a string representation of a <a href="#type-context_elem"><code>context_elem</code></a></p></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-server"><a href="#type-server" class="anchor"></a><code><span><span class="keyword">type</span> server</span><span> = </span><span>{</span></code><ol><li id="type-server.ioserver" class="def record field anchored"><a href="#type-server.ioserver" class="anchor"></a><code><span>ioserver : <a href="../Utils/Cmd/IOServer/index.html#type-t">Utils.Cmd.IOServer.t</a>;</span></code></li><li id="type-server.config" class="def record field anchored"><a href="#type-server.config" class="anchor"></a><code><span>config : <a href="../Config/File/Z3/index.html#type-t">Config.File.Z3.t</a>;</span></code></li><li id="type-server.context" class="def record field anchored"><a href="#type-server.context" class="anchor"></a><code><span><span class="keyword">mutable</span> context : <a href="#type-context">context</a>;</span></code></li></ol><code><span>}</span></code></div><div class="spec-doc"><p>The type of a Z3 server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-server"><a href="#val-server" class="anchor"></a><code><span><span class="keyword">val</span> server : <span><span><a href="#type-server">server</a> option</span> <span class="xref-unresolved">Stdlib</span>.ref</span></span></code></div><div class="spec-doc"><p>The global Z3 server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_server"><a href="#val-get_server" class="anchor"></a><code><span><span class="keyword">val</span> get_server : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-server">server</a></span></code></div><div class="spec-doc"><p>Assume the server is started and returns it.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-raw_start"><a href="#val-raw_start" class="anchor"></a><code><span><span class="keyword">val</span> raw_start : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start Z3 without any checks and without sending intro or pushing</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-raw_stop"><a href="#val-raw_stop" class="anchor"></a><code><span><span class="keyword">val</span> raw_stop : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop Z3 without asking politely</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_context_string"><a href="#val-get_context_string" class="anchor"></a><code><span><span class="keyword">val</span> get_context_string : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Give a string representation of the current context for error reporting</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-incr_context"><a href="#val-incr_context" class="anchor"></a><code><span><span class="keyword">val</span> incr_context : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Increment the declaration number of the top <a href="#type-context_elem"><code>context_elem</code></a>.</p></div></div><h2 id="request-and-answer-management"><a href="#request-and-answer-management" class="anchor"></a>Request and answer management</h2><p>This section handle raw and less raw direct interaction with the Z3 server.</p><p>The <code>send_*</code> function are for sending information to the server with a server handle. This avoided checking if the server is open at each declaration.</p><p>The <code>read_*</code> functions are the same the other way around.</p><p>The <a href="#val-request"><code>request</code></a> and <a href="#val-command"><code>command</code></a> are high level versions</p><div class="odoc-spec"><div class="spec value anchored" id="val-send_string"><a href="#val-send_string" class="anchor"></a><code><span><span class="keyword">val</span> send_string : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Send a string to the server and increment the declaration number in the context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_smt"><a href="#val-send_smt" class="anchor"></a><code><span><span class="keyword">val</span> send_smt : 
+  <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span>
+  <span><span class="optlabel">?ppv</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Send a smt statement to the server and increment the declaration number in the context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_string"><a href="#val-read_string" class="anchor"></a><code><span><span class="keyword">val</span> read_string : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Read a string from the server (A Z3 answer is always a valid sexp)</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-read_smt_ans"><a href="#val-read_smt_ans" class="anchor"></a><code><span><span class="keyword">val</span> read_smt_ans : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a></span></code></div><div class="spec-doc"><p>Read a <code>smt_ans</code> from the server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-request"><a href="#val-request" class="anchor"></a><code><span><span class="keyword">val</span> request : 
+  <span><span class="optlabel">?ppv</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  <a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a></span></code></div><div class="spec-doc"><p>Make a request to the server and expect an answer. Will hang if there is no answer</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-command"><a href="#val-command" class="anchor"></a><code><span><span class="keyword">val</span> command : 
+  <span><span class="optlabel">?ppv</span>:<span>(<span><span class="type-var">'a</span> <span class="arrow">&#45;&gt;</span></span> <a href="../Utils/Pp/index.html#type-document">Utils.Pp.document</a>)</span> <span class="arrow">&#45;&gt;</span></span>
+  <span><span><span>(<span class="type-var">'b</span>, <span class="type-var">'a</span>, string, <a href="../AstGen/Def/Size/index.html#type-t">AstGen.Def.Size.t</a>)</span> <a href="../AstGen/Ott/index.html#type-smt">AstGen.Ott.smt</a></span> <span class="arrow">&#45;&gt;</span></span>
+  unit</span></code></div><div class="spec-doc"><p>Send a command or a declaration to the server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_version"><a href="#val-expect_version" class="anchor"></a><code><span><span class="keyword">val</span> expect_version : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a> <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Expect a version answer and fails if it is not the case</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expect_exp"><a href="#val-expect_exp" class="anchor"></a><code><span><span class="keyword">val</span> expect_exp : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="../Ast/index.html#type-rsmt_ans">Ast.rsmt_ans</a> <span class="arrow">&#45;&gt;</span></span> <a href="../Ast/index.html#type-rexp">Ast.rexp</a></span></code></div><div class="spec-doc"><p>Expect an expression answer and fails if it is not the case</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_version"><a href="#val-get_version" class="anchor"></a><code><span><span class="keyword">val</span> get_version : <span>unit <span class="arrow">&#45;&gt;</span></span> string</span></code></div><div class="spec-doc"><p>Get the Z3 version string</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_context_sat"><a href="#val-is_context_sat" class="anchor"></a><code><span><span class="keyword">val</span> is_context_sat : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if the current context is sat</p></div></div><h2 id="full-startup-and-shutdown"><a href="#full-startup-and-shutdown" class="anchor"></a>Full startup and shutdown</h2><div class="odoc-spec"><div class="spec value anchored" id="val-stop"><a href="#val-stop" class="anchor"></a><code><span><span class="keyword">val</span> stop : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Stop the Z3 server properly</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_stopped"><a href="#val-ensure_stopped" class="anchor"></a><code><span><span class="keyword">val</span> ensure_stopped : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Call <a href="#val-stop"><code>stop</code></a> if the server wasn't stopped</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-start"><a href="#val-start" class="anchor"></a><code><span><span class="keyword">val</span> start : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Start the Z3 Server and setup the intro</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_started"><a href="#val-ensure_started" class="anchor"></a><code><span><span class="keyword">val</span> ensure_started : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Call <a href="#val-start"><code>start</code></a> if the server wasn't started</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ensure_started_get"><a href="#val-ensure_started_get" class="anchor"></a><code><span><span class="keyword">val</span> ensure_started_get : <span>unit <span class="arrow">&#45;&gt;</span></span> <a href="#type-server">server</a></span></code></div><div class="spec-doc"><p>Call <a href="#val-start"><code>start</code></a> if the server wasn't started, then return the server</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span>unit <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Reset the Z3 server, forgetting everything. Useful for resetting in a test failure context, but probably shouldn't be used in normal operations</p></div></div><h2 id="context"><a href="#context" class="anchor"></a>Context management</h2><p>Z3 contexts are managed in a stack way.</p><p>There are implemented using <code>(push)</code> and <code>(pop)</code> on the Z3 side.</p><p><a href="#val-open_context"><code>open_context</code></a> can open a named context. However if it is expected to open a given context name multiple times, using <a href="ContextCounter/index.html"><code>ContextCounter</code></a> is advised.</p><div class="odoc-spec"><div class="spec value anchored" id="val-open_context"><a href="#val-open_context" class="anchor"></a><code><span><span class="keyword">val</span> open_context : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span>string <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Open a new context with a name.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-close_context"><a href="#val-close_context" class="anchor"></a><code><span><span class="keyword">val</span> close_context : <span><a href="#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Closes current context of the server</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-ContextCounter"><a href="#module-ContextCounter" class="anchor"></a><code><span><span class="keyword">module</span> <a href="ContextCounter/index.html">ContextCounter</a></span><span> (<a href="ContextCounter/argument-1-S/index.html">S</a> : <a href="../Utils/Logs/module-type-String/index.html">Utils.Logs.String</a>) : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>Module for handling a context numbering scheme automatically.</p></div></div><h2 id="high-level-interaction"><a href="#high-level-interaction" class="anchor"></a>High level interaction</h2><p>This section provide functor that can be instantiated to get easy to use SMT functionality</p><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-Var"><a href="#module-type-Var" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-Var/index.html">Var</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div><div class="spec-doc"><p>The functors in this section require a bit more support from variable than plain <a href="../Exp/module-type-Var/index.html"><code>Exp.Var</code></a></p></div></div><div class="odoc-spec"><div class="spec module-type anchored" id="module-type-S"><a href="#module-type-S" class="anchor"></a><code><span><span class="keyword">module</span> <span class="keyword">type</span> <a href="module-type-S/index.html">S</a></span><span> = <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-SimpContext"><a href="#module-SimpContext" class="anchor"></a><code><span><span class="keyword">module</span> <a href="SimpContext/index.html">SimpContext</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-CheckContext"><a href="#module-CheckContext" class="anchor"></a><code><span><span class="keyword">module</span> <a href="CheckContext/index.html">CheckContext</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Make"><a href="#module-Make" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Make/index.html">Make</a></span><span> (<a href="Make/argument-1-Var/index.html">Var</a> : <a href="module-type-Var/index.html">Var</a>) : <a href="module-type-S/index.html">S</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="module-type-S/index.html#type-var">var</a> = <a href="Make/argument-1-Var/index.html#type-t">Var.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Test"><a href="#module-Test" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Test/index.html">Test</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/module-type-S/index.html b/doc/html/read-dwarf/Z3/module-type-S/index.html
index fc0014a9..eeb82f69 100644
--- a/doc/html/read-dwarf/Z3/module-type-S/index.html
+++ b/doc/html/read-dwarf/Z3/module-type-S/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Z3.S)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; S</nav><h1>Module type <code>Z3.S</code></h1><nav class="toc"><ul><li><a href="#variable-declarations">Variable declarations</a></li><li><a href="#simplification">Simplification</a></li><li><a href="#smt-checking">SMT checking</a></li><li><a href="#nocontext">Context less operation</a></li></ul></nav></header><dl><dt class="spec type" id="type-var"><a href="#type-var" class="anchor"></a><code><span class="keyword">type</span> var</code></dt></dl><section><header><h2 id="variable-declarations"><a href="#variable-declarations" class="anchor"></a>Variable declarations</h2><p>The goal of those operation is to declare variables with their types to the SMT solver. The <a href="Htbl/index.html"><code>Htbl</code></a> allow to declare every variable only once.</p></header><dl><dt class="spec type" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span class="keyword">type</span> exp</code><code> = <span><span>(<a href="index.html#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></code></dt><dd><p>The type of expression on which SMT operation are made</p></dd></dl><dl><dt class="spec module" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span class="keyword">module</span> Htbl : Stdlib.Hashtbl.S <span class="keyword">with</span> <span class="keyword">type</span> <a href="index.html#module-Htbl">Htbl</a>.key = <a href="index.html#type-var">var</a></code></dt><dd><p>Hash tables over variables</p></dd></dl><dl><dt class="spec value" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span class="keyword">val</span> declare_var_always : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Declare the variable regardless of whether it has already been declared</p></dd></dl><dl><dt class="spec value" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span class="keyword">val</span> declare_var : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-var">var</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Declare the variable if it's not in <code>declared</code>. In that case, it also add it to <code>declared</code></p></dd></dl><dl><dt class="spec value" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span class="keyword">val</span> declare_vars : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Declare all not yet declared the variable in the expression, then add them to <code>declared</code></p></dd></dl></section><section><header><h2 id="simplification"><a href="#simplification" class="anchor"></a>Simplification</h2></header><dl><dt class="spec value" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span class="keyword">val</span> simplify : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Simplify the expression in the current context. All the variable must already have been declared.</p></dd></dl><dl><dt class="spec value" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span class="keyword">val</span> simplify_decl : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Literally just <a href="index.html#val-declare_vars"><code>declare_vars</code></a> then <a href="index.html#val-simplify"><code>simplify</code></a></p></dd></dl></section><section><header><h2 id="smt-checking"><a href="#smt-checking" class="anchor"></a>SMT checking</h2></header><dl><dt class="spec value" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span class="keyword">val</span> send_assert : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Assert that expression in the current context</p></dd></dl><dl><dt class="spec value" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span class="keyword">val</span> send_assert_decl : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <span>declared:<span>unit <a href="index.html#module-Htbl">Htbl</a>.t</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> unit</code></dt><dd><p>Literally just <a href="index.html#val-declare_vars"><code>declare_vars</code></a> then <a href="index.html#val-send_assert"><code>send_assert</code></a></p></dd></dl><dl><dt class="spec value" id="val-check"><a href="#val-check" class="anchor"></a><code><span class="keyword">val</span> check : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if this expression is always true in the current context. <code>None</code> is returned when the SMT solver didn't know</p></dd></dl><dl><dt class="spec value" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span class="keyword">val</span> check_sat : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if this expression is true on at least one assignment of the variables.ioserver <code>None</code> is returned when the SMT solver didn't know</p></dd></dl><dl><dt class="spec value" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span class="keyword">val</span> check_both : <a href="../index.html#type-server">server</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Check if this expression is always true of always false. <code>None</code> is returned if neither can be proven.</p><p>This results in two calls to the SMT solver. one with <a href="index.html#val-check"><code>check</code></a> and one with <a href="index.html#val-check_sat"><code>check_sat</code></a></p></dd></dl></section><section><header><h2 id="nocontext"><a href="#nocontext" class="anchor"></a>Context less operation</h2><p>Those operations do not require a context to operate. They require not setup and tear-down. They are standalone and fully automated.</p><p>On the other hand doing multiple one of those in sequence if much less efficient than using properly the functions of previous section.</p></header><dl><dt class="spec value" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span class="keyword">val</span> simplify_full : <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a></code></dt><dd><p>Do a standalone simplification in it's own context. Do not need anything to be already declared or any context to be opened.</p></dd></dl><dl><dt class="spec value" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span class="keyword">val</span> check_full : <span>?&#8288;hyps:<span><a href="index.html#type-exp">exp</a> list</span></span> <span>&#45;&gt;</span> <a href="index.html#type-exp">exp</a> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Do a standalone check of whether the expression is implied by the list of hypothesis.</p></dd></dl><dl><dt class="spec value" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span class="keyword">val</span> check_sat_full : <span><a href="index.html#type-exp">exp</a> list</span> <span>&#45;&gt;</span> <span>bool option</span></code></dt><dd><p>Do a standalone check of whether the set of assertion is sat</p></dd></dl></section></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>S (read-dwarf.Z3.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; S</nav><header class="odoc-preamble"><h1>Module type <code><span>Z3.S</span></code></h1></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#variable-declarations">Variable declarations</a></li><li><a href="#simplification">Simplification</a></li><li><a href="#smt-checking">SMT checking</a></li><li><a href="#nocontext">Context less operation</a></li></ul></nav></div><div class="odoc-content"><div class="odoc-spec"><div class="spec type anchored" id="type-var"><a href="#type-var" class="anchor"></a><code><span><span class="keyword">type</span> var</span></code></div></div><h2 id="variable-declarations"><a href="#variable-declarations" class="anchor"></a>Variable declarations</h2><p>The goal of those operation is to declare variables with their types to the SMT solver. The <a href="Htbl/index.html"><code>Htbl</code></a> allow to declare every variable only once.</p><div class="odoc-spec"><div class="spec type anchored" id="type-exp"><a href="#type-exp" class="anchor"></a><code><span><span class="keyword">type</span> exp</span><span> = <span><span>(<a href="#type-var">var</a>, <a href="../../Ast/index.html#type-no">Ast.no</a>)</span> <a href="../../Exp/Typed/index.html#type-t">Exp.Typed.t</a></span></span></code></div><div class="spec-doc"><p>The type of expression on which SMT operation are made</p></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Htbl"><a href="#module-Htbl" class="anchor"></a><code><span><span class="keyword">module</span> Htbl</span><span> : <span class="xref-unresolved">Stdlib</span>.Hashtbl.S <span class="keyword">with</span> <span><span class="keyword">type</span> <span class="xref-unresolved">key</span> = <span class="xref-unresolved">var</span></span></span></code></div><div class="spec-doc"><p>Hash tables over variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var_always"><a href="#val-declare_var_always" class="anchor"></a><code><span><span class="keyword">val</span> declare_var_always : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Declare the variable regardless of whether it has already been declared</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_var"><a href="#val-declare_var" class="anchor"></a><code><span><span class="keyword">val</span> declare_var : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-var">var</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Declare the variable if it's not in <code>declared</code>. In that case, it also add it to <code>declared</code></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-declare_vars"><a href="#val-declare_vars" class="anchor"></a><code><span><span class="keyword">val</span> declare_vars : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Declare all not yet declared the variable in the expression, then add them to <code>declared</code></p></div></div><h2 id="simplification"><a href="#simplification" class="anchor"></a>Simplification</h2><div class="odoc-spec"><div class="spec value anchored" id="val-simplify"><a href="#val-simplify" class="anchor"></a><code><span><span class="keyword">val</span> simplify : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Simplify the expression in the current context. All the variable must already have been declared.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_decl"><a href="#val-simplify_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_decl : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Literally just <a href="#val-declare_vars"><code>declare_vars</code></a> then <a href="#val-simplify"><code>simplify</code></a></p></div></div><h2 id="smt-checking"><a href="#smt-checking" class="anchor"></a>SMT checking</h2><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert"><a href="#val-send_assert" class="anchor"></a><code><span><span class="keyword">val</span> send_assert : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Assert that expression in the current context</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-send_assert_decl"><a href="#val-send_assert_decl" class="anchor"></a><code><span><span class="keyword">val</span> send_assert_decl : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> unit</span></code></div><div class="spec-doc"><p>Literally just <a href="#val-declare_vars"><code>declare_vars</code></a> then <a href="#val-send_assert"><code>send_assert</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check"><a href="#val-check" class="anchor"></a><code><span><span class="keyword">val</span> check : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if this expression is always true in the current context. <code>None</code> is returned when the SMT solver didn't know</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat"><a href="#val-check_sat" class="anchor"></a><code><span><span class="keyword">val</span> check_sat : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if this expression is true on at least one assignment of the variables.ioserver <code>None</code> is returned when the SMT solver didn't know</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_both"><a href="#val-check_both" class="anchor"></a><code><span><span class="keyword">val</span> check_both : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Check if this expression is always true of always false. <code>None</code> is returned if neither can be proven.</p><p>This results in two calls to the SMT solver. one with <a href="#val-check"><code>check</code></a> and one with <a href="#val-check_sat"><code>check_sat</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms"><a href="#val-simplify_subterms" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_decl"><a href="#val-simplify_subterms_decl" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_decl : <span><a href="../index.html#type-server">server</a> <span class="arrow">&#45;&gt;</span></span> <span><span class="label">declared</span>:<span>unit <span class="xref-unresolved">Htbl</span>.t</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div><h2 id="nocontext"><a href="#nocontext" class="anchor"></a>Context less operation</h2><p>Those operations do not require a context to operate. They require not setup and tear-down. They are standalone and fully automated.</p><p>On the other hand doing multiple one of those in sequence if much less efficient than using properly the functions of previous section.</p><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_full"><a href="#val-simplify_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_full : <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div><div class="spec-doc"><p>Do a standalone simplification in it's own context. Do not need anything to be already declared or any context to be opened.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_full"><a href="#val-check_full" class="anchor"></a><code><span><span class="keyword">val</span> check_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Do a standalone check of whether the expression is implied by the list of hypothesis.</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-check_sat_full"><a href="#val-check_sat_full" class="anchor"></a><code><span><span class="keyword">val</span> check_sat_full : <span><span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span>bool option</span></span></code></div><div class="spec-doc"><p>Do a standalone check of whether the set of assertion is sat</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-simplify_subterms_full"><a href="#val-simplify_subterms_full" class="anchor"></a><code><span><span class="keyword">val</span> simplify_subterms_full : <span><span class="optlabel">?hyps</span>:<span><a href="#type-exp">exp</a> list</span> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-exp">exp</a> <span class="arrow">&#45;&gt;</span></span> <a href="#type-exp">exp</a></span></code></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/Z3/module-type-Var/index.html b/doc/html/read-dwarf/Z3/module-type-Var/index.html
index bf6d4ad2..0ccc033e 100644
--- a/doc/html/read-dwarf/Z3/module-type-Var/index.html
+++ b/doc/html/read-dwarf/Z3/module-type-Var/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Z3.Var)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; Var</nav><h1>Module type <code>Z3.Var</code></h1><p>The functors in this section require a bit more support from variable than plain <a href="../../Exp/module-type-Var/index.html"><code>Exp.Var</code></a></p></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../Exp/index.html#module-type-Var">Exp.Var</a></code></span></summary><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>The type of variables</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Equality predicate that will be passed to expressions</p></dd></dl><dl><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Utils/index.html#module-Pp">Utils.Pp</a>.document</code></dt><dd><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></dd></dl><dl><dt class="spec value" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span class="keyword">val</span> ty : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="../../Exp/index.html#type-ty">Exp.ty</a></code></dt><dd><p>Get the type of the variable</p></dd></dl></details></div></div></div><dl><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dd><p>Hashing function to store variable in <code>Hashtbl</code>s. Must be compatible with <a href="index.html#val-equal"><code>equal</code></a></p></dd></dl><dl><dt class="spec value" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span class="keyword">val</span> of_string : string <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Parser from a string. Must be the inverse of <a href="index.html#val-pp"><code>pp</code></a></p></dd></dl></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Var (read-dwarf.Z3.Var)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../../../index.html">Index</a> &#x00BB; <a href="../../index.html">read-dwarf</a> &#x00BB; <a href="../index.html">Z3</a> &#x00BB; Var</nav><header class="odoc-preamble"><h1>Module type <code><span>Z3.Var</span></code></h1><p>The functors in this section require a bit more support from variable than plain <a href="../../Exp/module-type-Var/index.html"><code>Exp.Var</code></a></p></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../Exp/module-type-Var/index.html">Exp.Var</a></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-t"><a href="#type-t" class="anchor"></a><code><span><span class="keyword">type</span> t</span></code></div><div class="spec-doc"><p>The type of variables</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> bool</span></code></div><div class="spec-doc"><p>Equality predicate that will be passed to expressions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span><span class="keyword">val</span> pp : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Utils/Pp/index.html#type-document">Utils.Pp.document</a></span></code></div><div class="spec-doc"><p>Pretty printer to be used, both for memory pretty printing and for sending memory to Z3</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ty"><a href="#val-ty" class="anchor"></a><code><span><span class="keyword">val</span> ty : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> <a href="../../Exp/index.html#type-ty">Exp.ty</a></span></code></div><div class="spec-doc"><p>Get the type of the variable</p></div></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span><span class="keyword">val</span> hash : <span><a href="#type-t">t</a> <span class="arrow">&#45;&gt;</span></span> int</span></code></div><div class="spec-doc"><p>Hashing function to store variable in <code>Hashtbl</code>s. Must be compatible with <a href="#val-equal"><code>equal</code></a></p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_string"><a href="#val-of_string" class="anchor"></a><code><span><span class="keyword">val</span> of_string : <span>string <span class="arrow">&#45;&gt;</span></span> <a href="#type-t">t</a></span></code></div><div class="spec-doc"><p>Parser from a string. Must be the inverse of <a href="#val-pp"><code>pp</code></a></p></div></div></div></body></html>
diff --git a/doc/html/read-dwarf/index.html b/doc/html/read-dwarf/index.html
index 80f9cd2a..c05c2753 100644
--- a/doc/html/read-dwarf/index.html
+++ b/doc/html/read-dwarf/index.html
@@ -1,2 +1,2 @@
 <!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>index (read-dwarf.index)</title><link rel="stylesheet" href="../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.1"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – read-dwarf</nav><h1 id="read-dwarf"><a href="#read-dwarf" class="anchor"></a>read-dwarf</h1><p>read-dwarf is a tool for exploring, symbolically executing and validating ELF binaries generated from C, using DWARF debugging information. It will be used to perform translation validation between O0 and O2 binaries. It is written in OCaml and relies on many other tools. Its current set of features allows a user to explore binaries with the source code inlined, and for simple cases, symbolically evaluate a function, check two versions of the same function (compiled at O0 and O2 optimisation levels) evaluate to the same machine state (given a simulation relation) and compute branch tables for indirect jumps. We intend to build upon this foundation of features to handle all more functions, by incorporating information from higher-levels, inferring types and pointer-provenance, inferring simulation relations automatically, and supporting concurrency models for Arm v8.</p><p>This documentation is for the internal code of read-dwarf.</p><nav class="toc"><ul><li><a href="#overview">Overview</a></li><li><a href="#detailed-pages">Detailed pages</a></li><li><a href="#dependencies">Dependencies</a></li><li><a href="#alphabetical-index">Alphabetical index</a></li></ul></nav></header><h2 id="overview"><a href="#overview" class="anchor"></a>Overview</h2><p>Currently read-dwarf does not yet have the actual infrastructure to find a simulation relation between two binaries, however it already has all the necessary infrastructure to run symbolicaly a binary through any control flow path, and infer the C type along the way. The exact C-like type-system used is a bit more advanced than C.</p><p>I'll attempt here to give a pipeline overview of what happens when you want to run a function symbolically. All of this is done by the <a href="Run/Func/index.html"><code>Run.Func</code></a> module that provide a CLI to run a single function symbolically.</p><ul><li>The binary is parsed by the linksem library using the <a href="Elf/index.html"><code>Elf</code></a> and <a href="Dw/index.html"><code>Dw</code></a> modules. In this phase C-Type linking happens as described in <a href="Ctype/index.html#ctyplink"><span>C type linking: From Linksem</span></a></li><li>The function name is found and used in the <a href="Dw/Func/index.html"><code>Dw.Func</code></a> format.</li><li>The API and ABI of the function are computed according to the current achitecture. The generic <a href="Architecture.html"><code>Architecture</code></a> interface is defined in the virtual module <a href="Sig/index.html"><code>Sig</code></a> but the only implementation is in <code>src/arch/aarch64/sig.ml</code> (<a href="https://github.com/ocaml/dune/commit/1ce94b47e9640419bb7e644d6da1e0f53e9b23d9">dune doesn't build docs for virtual module implementations :(</a>).</li><li>If we suppose the instruction caches are empty, the <a href="Isla/Server/index.html"><code>Isla.Server</code></a> will be started and used by <a href="Run/Init/index.html"><code>Run.Init</code></a> to fetch the machine initial <a href="State/index.html"><code>State</code></a>. This will call <code>isla</code> to get the trace of the <code>nop</code> instruction. See <a href="InstructionPipeline.html"><code>InstructionPipeline</code></a></li><li>The function entry <a href="State/index.html"><code>State</code></a> can be computed from the machine initial state and the ABI.</li><li>We load the symbolic execution engine <a href="Run/Runner/index.html"><code>Run.Runner</code></a> with the DWARF information and initialize it.</li><li>We create a <a href="Run/Block/index.html"><code>Run.Block</code></a> which is a piece of code that can run a delimited block of code. We give to it the end conditions provided by the command line like potential breakpoints. Then we run it.</li><li>The <a href="Run/Block/index.html"><code>Run.Block</code></a> calls the <a href="Run/Runner/index.html"><code>Run.Runner</code></a> on each instruction as needed to move forward and build the tree (<a href="State/Tree/index.html"><code>State.Tree</code></a>) of possible states. For each instruction, the whole <a href="InstructionPipeline.html"><code>InstructionPipeline</code></a> is run to generate a set of <a href="Trace/index.html"><code>Trace</code></a>s and this set of traces is run on a <a href="State/index.html"><code>State</code></a> to get the next state. See <a href="SymbolicExecution.html"><code>SymbolicExecution</code></a>.</li><li>Then we pretty print the results using <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> and <a href="Utils/Logs/index.html"><code>Utils.Logs</code></a>. See <a href="Printing.html"><code>Printing</code></a></li></ul><h2 id="detailed-pages"><a href="#detailed-pages" class="anchor"></a>Detailed pages</h2><p>Here is a list of top-level pages that each explains a subgroup of functionality:</p><ul><li><a href="Architecture.html"><code>Architecture</code></a>: All modules related to achitecture representation</li><li><a href="BinaryAnalysis.html"><code>BinaryAnalysis</code></a>: All modules about reading ELF and DWARF information</li><li><a href="CLI.html"><code>CLI</code></a>: All modules defining the command line interfaces.</li><li><a href="Configuration.html"><code>Configuration</code></a>: Configuration organisation</li><li><a href="InstructionPipeline.html"><code>InstructionPipeline</code></a>: All modules related to instruction semantics processing.</li><li><a href="Printing.html"><code>Printing</code></a>: Generic information about printing and logging</li><li><a href="SymbolicExecution.html"><code>SymbolicExecution</code></a>: All modules related to top-level symbolic execution.</li><li><a href="SymbolicExpressions.html"><code>SymbolicExpressions</code></a>: All modules related to symbolic expression manipulation</li><li><a href="TypeInference.html"><code>TypeInference</code></a>: All modules about the C type system and type inference.</li><li><a href="Utilities.html"><code>Utilities</code></a>: List of modules that provide generic functionality</li></ul><h2 id="dependencies"><a href="#dependencies" class="anchor"></a>Dependencies</h2><p>Here is a list of the dependency libraries that are used, and links to their documentation (for those that have some).</p><ul><li><code>linksem</code> : ELF and DWARF Parser and analyzer</li><li><code>isla-lang</code>: Isla traces parser</li><li><a href="https://erratique.ch/software/cmdliner/doc/Cmdliner"><code>cmdliner</code></a>: Library to parse the command line.</li><li><a href="http://cambium.inria.fr/~fpottier/pprint/doc/pprint/PPrint/index.html"><code>pprint</code></a>: Pretty-printing library. Use it via the <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> module.</li><li><a href="https://antoinemine.github.io/Zarith/doc/latest/index.html"><code>zarith</code></a>: Big integer library. Used by <code>linksem</code> and all <code>linksem</code> interacting modules, and by <a href="Utils/BitVec/index.html"><code>Utils.BitVec</code></a>.</li><li><a href="http://mmottl.github.io/res/api/res/"><code>res</code></a>: Resizable array. Use it via the <code>Vec</code> module</li><li><a href="http://ocamlgraph.lri.fr/doc/"><code>ocamlgraph</code></a>: Graph library. Only used in <a href="Analyse/index.html"><code>Analyse</code></a> for now; may be used elsewhere later.</li><li><a href="http://ocaml-toml.github.io/To.ml/"><code>toml</code></a> Toml Parsing library. Only used in <a href="Config/File/index.html"><code>Config.File</code></a> to parse the config file. It should not be used elsewhere.</li><li><a href="https://erratique.ch/software/uutf/doc/Uutf"><code>uutf</code></a> : Unicode library. Only used to do UTF-8 character folding in <a href="Analyse/index.html"><code>Analyse</code></a>. Those utility function should probably move to <a href="Utils/String/index.html"><code>Utils.String</code></a> to be accessible elsewhere.</li></ul><h2 id="alphabetical-index"><a href="#alphabetical-index" class="anchor"></a>Alphabetical index</h2><p>Here is an alphabetical list of all modules, except <code>src/arch/aarch64/sig.ml</code>.</p><ul class="modules"><li><a href="Analyse/index.html"><code>Analyse</code></a></li><li><a href="Arch/index.html"><code>Arch</code></a></li><li><a href="Ast/index.html"><code>Ast</code></a></li><li><a href="BranchTable/index.html"><code>BranchTable</code></a></li><li><a href="Config/index.html"><code>Config</code></a></li><li><a href="Ctype/index.html"><code>Ctype</code></a></li><li><a href="Dw/index.html"><code>Dw</code></a></li><li><a href="Elf/index.html"><code>Elf</code></a></li><li><a href="Exp/index.html"><code>Exp</code></a></li><li><a href="AstGen/index.html"><code>AstGen</code></a></li><li><a href="Isla/index.html"><code>Isla</code></a></li><li><a href="Other_cmds/index.html"><code>Other_cmds</code></a></li><li><a href="Run/index.html"><code>Run</code></a></li><li><a href="Simrel/index.html"><code>Simrel</code></a></li><li><a href="State/index.html"><code>State</code></a></li><li><a href="Tests/index.html"><code>Tests</code></a></li><li><a href="Trace/index.html"><code>Trace</code></a></li><li><a href="Utils/index.html"><code>Utils</code></a></li><li><a href="Z3/index.html"><code>Z3</code></a></li></ul></div></body></html>
\ No newline at end of file
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>index (read-dwarf.index)</title><meta charset="utf-8"/><link rel="stylesheet" href="../odoc.support/odoc.css"/><meta name="generator" content="odoc 3.0.0"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> – <a href="../index.html">Index</a> &#x00BB; read-dwarf</nav><header class="odoc-preamble"><h1 id="read-dwarf"><a href="#read-dwarf" class="anchor"></a>read-dwarf</h1><p>read-dwarf is a tool for exploring, symbolically executing and validating ELF binaries generated from C, using DWARF debugging information. It will be used to perform translation validation between O0 and O2 binaries. It is written in OCaml and relies on many other tools. Its current set of features allows a user to explore binaries with the source code inlined, and for simple cases, symbolically evaluate a function, check two versions of the same function (compiled at O0 and O2 optimisation levels) evaluate to the same machine state (given a simulation relation) and compute branch tables for indirect jumps. We intend to build upon this foundation of features to handle all more functions, by incorporating information from higher-levels, inferring types and pointer-provenance, inferring simulation relations automatically, and supporting concurrency models for Arm v8.</p><p>This documentation is for the internal code of read-dwarf.</p></header><div class="odoc-tocs"><nav class="odoc-toc odoc-local-toc"><ul><li><a href="#overview">Overview</a></li><li><a href="#detailed-pages">Detailed pages</a></li><li><a href="#dependencies">Dependencies</a></li><li><a href="#alphabetical-index">Alphabetical index</a></li></ul></nav></div><div class="odoc-content"><h2 id="overview"><a href="#overview" class="anchor"></a>Overview</h2><p>Currently read-dwarf does not yet have the actual infrastructure to find a simulation relation between two binaries, however it already has all the necessary infrastructure to run symbolicaly a binary through any control flow path, and infer the C type along the way. The exact C-like type-system used is a bit more advanced than C.</p><p>I'll attempt here to give a pipeline overview of what happens when you want to run a function symbolically. All of this is done by the <a href="Run/Func/index.html"><code>Run.Func</code></a> module that provide a CLI to run a single function symbolically.</p><ul><li>The binary is parsed by the linksem library using the <a href="Elf/index.html"><code>Elf</code></a> and <a href="Dw/index.html"><code>Dw</code></a> modules. In this phase C-Type linking happens as described in <a href="Ctype/index.html#ctyplink" title="ctyplink">C type linking: From Linksem</a></li><li>The function name is found and used in the <a href="Dw/Func/index.html"><code>Dw.Func</code></a> format.</li><li>The API and ABI of the function are computed according to the current achitecture. The generic <a href="Architecture.html"><code>Architecture</code></a> interface is defined in the virtual module <a href="Sig/index.html"><code>Sig</code></a> but the only implementation is in <code>src/arch/aarch64/sig.ml</code> (<a href="https://github.com/ocaml/dune/commit/1ce94b47e9640419bb7e644d6da1e0f53e9b23d9">dune doesn't build docs for virtual module implementations :(</a>).</li><li>If we suppose the instruction caches are empty, the <a href="Isla/Server/index.html"><code>Isla.Server</code></a> will be started and used by <a href="Run/Init/index.html"><code>Run.Init</code></a> to fetch the machine initial <a href="State/index.html"><code>State</code></a>. This will call <code>isla</code> to get the trace of the <code>nop</code> instruction. See <a href="InstructionPipeline.html"><code>InstructionPipeline</code></a></li><li>The function entry <a href="State/index.html"><code>State</code></a> can be computed from the machine initial state and the ABI.</li><li>We load the symbolic execution engine <a href="Run/Runner/index.html"><code>Run.Runner</code></a> with the DWARF information and initialize it.</li><li>We create a <a href="Run/Block/index.html"><code>Run.Block</code></a> which is a piece of code that can run a delimited block of code. We give to it the end conditions provided by the command line like potential breakpoints. Then we run it.</li><li>The <a href="Run/Block/index.html"><code>Run.Block</code></a> calls the <a href="Run/Runner/index.html"><code>Run.Runner</code></a> on each instruction as needed to move forward and build the tree (<a href="State/Tree/index.html"><code>State.Tree</code></a>) of possible states. For each instruction, the whole <a href="InstructionPipeline.html"><code>InstructionPipeline</code></a> is run to generate a set of <a href="Trace/index.html"><code>Trace</code></a>s and this set of traces is run on a <a href="State/index.html"><code>State</code></a> to get the next state. See <a href="SymbolicExecution.html"><code>SymbolicExecution</code></a>.</li><li>Then we pretty print the results using <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> and <a href="Utils/Logs/index.html"><code>Utils.Logs</code></a>. See <a href="Printing.html"><code>Printing</code></a></li></ul><h2 id="detailed-pages"><a href="#detailed-pages" class="anchor"></a>Detailed pages</h2><p>Here is a list of top-level pages that each explains a subgroup of functionality:</p><ul><li><a href="Architecture.html"><code>Architecture</code></a>: All modules related to achitecture representation</li><li><a href="BinaryAnalysis.html"><code>BinaryAnalysis</code></a>: All modules about reading ELF and DWARF information</li><li><a href="CLI.html"><code>CLI</code></a>: All modules defining the command line interfaces.</li><li><a href="Configuration.html"><code>Configuration</code></a>: Configuration organisation</li><li><a href="InstructionPipeline.html"><code>InstructionPipeline</code></a>: All modules related to instruction semantics processing.</li><li><a href="Printing.html"><code>Printing</code></a>: Generic information about printing and logging</li><li><a href="SymbolicExecution.html"><code>SymbolicExecution</code></a>: All modules related to top-level symbolic execution.</li><li><a href="SymbolicExpressions.html"><code>SymbolicExpressions</code></a>: All modules related to symbolic expression manipulation</li><li><a href="TypeInference.html"><code>TypeInference</code></a>: All modules about the C type system and type inference.</li><li><a href="Utilities.html"><code>Utilities</code></a>: List of modules that provide generic functionality</li></ul><h2 id="dependencies"><a href="#dependencies" class="anchor"></a>Dependencies</h2><p>Here is a list of the dependency libraries that are used, and links to their documentation (for those that have some).</p><ul><li><code>linksem</code> : ELF and DWARF Parser and analyzer</li><li><code>isla-lang</code>: Isla traces parser</li><li><a href="https://erratique.ch/software/cmdliner/doc/Cmdliner"><code>cmdliner</code></a>: Library to parse the command line.</li><li><a href="http://cambium.inria.fr/~fpottier/pprint/doc/pprint/PPrint/index.html"><code>pprint</code></a>: Pretty-printing library. Use it via the <a href="Utils/Pp/index.html"><code>Utils.Pp</code></a> module.</li><li><a href="https://antoinemine.github.io/Zarith/doc/latest/index.html"><code>zarith</code></a>: Big integer library. Used by <code>linksem</code> and all <code>linksem</code> interacting modules, and by <a href="Utils/BitVec/index.html"><code>Utils.BitVec</code></a>.</li><li><a href="http://mmottl.github.io/res/api/res/"><code>res</code></a>: Resizable array. Use it via the <code>Vec</code> module</li><li><a href="http://ocamlgraph.lri.fr/doc/"><code>ocamlgraph</code></a>: Graph library. Only used in <a href="Analyse/index.html"><code>Analyse</code></a> for now; may be used elsewhere later.</li><li><a href="http://ocaml-toml.github.io/To.ml/"><code>toml</code></a> Toml Parsing library. Only used in <a href="Config/File/index.html"><code>Config.File</code></a> to parse the config file. It should not be used elsewhere.</li><li><a href="https://erratique.ch/software/uutf/doc/Uutf"><code>uutf</code></a> : Unicode library. Only used to do UTF-8 character folding in <a href="Analyse/index.html"><code>Analyse</code></a>. Those utility function should probably move to <a href="Utils/String/index.html"><code>Utils.String</code></a> to be accessible elsewhere.</li></ul><h2 id="alphabetical-index"><a href="#alphabetical-index" class="anchor"></a>Alphabetical index</h2><p>Here is an alphabetical list of all modules, except <code>src/arch/aarch64/sig.ml</code>.</p><ul class="modules"><li><a href="Analyse/index.html"><code>Analyse</code></a> </li><li><a href="Arch/index.html"><code>Arch</code></a> <span class="synopsis">This module adds some code that is related to the Architecture specific modules but is in itself architecture independent.</span></li><li><a href="Ast/index.html"><code>Ast</code></a> </li><li><code>BranchTable</code> </li><li><a href="Config/index.html"><code>Config</code></a> </li><li><a href="Ctype/index.html"><code>Ctype</code></a> <span class="synopsis">This module provides the internal C-like type system. This type system is slightly different than the normal C type system. This module only provides the Ocaml datastructure to represent those types. The typing rules are implemented in <code>Trace.Typer</code>, where they are applied dire</span></li><li><a href="Dw/index.html"><code>Dw</code></a> <span class="synopsis">This module provides the specifically interpreted DWARF information needed for read-dwarf operations</span></li><li><a href="Elf/index.html"><code>Elf</code></a> </li><li><a href="Exp/index.html"><code>Exp</code></a> <span class="synopsis">This module intends to provider a convenience expression module by lifting function like equality or pretty printing from variable to expressions.</span></li><li><a href="AstGen/index.html"><code>AstGen</code></a> </li><li><a href="Isla/index.html"><code>Isla</code></a> </li><li><a href="Other_cmds/index.html"><code>Other_cmds</code></a> </li><li><a href="Run/index.html"><code>Run</code></a> </li><li><a href="Simrel/index.html"><code>Simrel</code></a> </li><li><a href="State/index.html"><code>State</code></a> </li><li><a href="Tests/index.html"><code>Tests</code></a> </li><li><a href="Trace/index.html"><code>Trace</code></a> </li><li><a href="Utils/index.html"><code>Utils</code></a> </li><li><a href="Z3/index.html"><code>Z3</code></a> <span class="synopsis">This module handles a Z3 server</span></li></ul></div></body></html>