Module Js_of_ocaml_compiler.Code

module Addr : sig ... end
module Var : sig ... end
type cont = Addr.t * Var.t list
type prim =
  1. | Vectlength
  2. | Array_get
  3. | Extern of string
  4. | Not
  5. | IsInt
  6. | Eq
  7. | Neq
  8. | Lt
  9. | Le
  10. | Ult
type array_or_not =
  1. | Array
  2. | NotArray
  3. | Unknown
module Native_string : sig ... end
type constant =
  1. | String of string
  2. | NativeString of Native_string.t
  3. | Float of Stdlib.Int64.t
  4. | Float_array of Stdlib.Int64.t array
  5. | Int of Targetint.t
  6. | Int32 of Stdlib.Int32.t
    (*

    Only produced when compiling to WebAssembly.

    *)
  7. | Int64 of Stdlib.Int64.t
  8. | NativeInt of Stdlib.Int32.t
    (*

    Only produced when compiling to WebAssembly.

    *)
  9. | Tuple of int * constant array * array_or_not
module Constant : sig ... end
type loc =
  1. | No
  2. | Before of Addr.t
  3. | After of Addr.t
val noloc : loc
val location_of_pc : int -> loc
type prim_arg =
  1. | Pv of Var.t
  2. | Pc of constant
type special =
  1. | Alias_prim of string
type mutability =
  1. | Immutable
  2. | Maybe_mutable
type field_type =
  1. | Non_float
  2. | Float
type expr =
  1. | Apply of {
    1. f : Var.t;
    2. args : Var.t list;
    3. exact : bool;
    }
  2. | Block of int * Var.t array * array_or_not * mutability
  3. | Field of Var.t * int * field_type
  4. | Closure of Var.t list * cont * Parse_info.t option
  5. | Constant of constant
  6. | Prim of prim * prim_arg list
  7. | Special of special
type instr =
  1. | Let of Var.t * expr
  2. | Assign of Var.t * Var.t
  3. | Set_field of Var.t * int * field_type * Var.t
  4. | Offset_ref of Var.t * int
  5. | Array_set of Var.t * Var.t * Var.t
  6. | Event of Parse_info.t
type last =
  1. | Return of Var.t
  2. | Raise of Var.t * [ `Normal | `Notrace | `Reraise ]
  3. | Stop
  4. | Branch of cont
  5. | Cond of Var.t * cont * cont
  6. | Switch of Var.t * cont array
  7. | Pushtrap of cont * Var.t * cont
  8. | Poptrap of cont
type block = {
  1. params : Var.t list;
  2. body : instr list;
  3. branch : last;
}
type program = {
  1. start : Addr.t;
  2. blocks : block Addr.Map.t;
  3. free_pc : Addr.t;
}
module Print : sig ... end
type 'c fold_blocs = block Addr.Map.t -> Addr.t -> (Addr.t -> 'c -> 'c) -> 'c -> 'c
type fold_blocs_poly = {
  1. fold : 'a. 'a fold_blocs;
}
val fold_closures : program -> (Var.t option -> Var.t list -> cont -> Parse_info.t option -> 'd -> 'd) -> 'd -> 'd

fold_closures p f init folds f over all closures in the program p, starting from the initial value init. For each closure, f is called with the following arguments: the closure name (enclosed in Stdlib.Some), its parameter list, the address and parameter instantiation of its first block, the optional closure location and the current accumulator. In addition, f is called on the initial block p.start, with None as the closure name. All closures in all blocks of p are included in the fold, not only the ones reachable from p.start.

val fold_closures_innermost_first : program -> (Var.t option -> Var.t list -> cont -> Parse_info.t option -> 'd -> 'd) -> 'd -> 'd

Similar to fold_closures, but applies the fold function to the innermost closures first. Unlike with fold_closures, only the closures reachable from p.start are considered.

val fold_closures_outermost_first : program -> (Var.t option -> Var.t list -> cont -> Parse_info.t option -> 'd -> 'd) -> 'd -> 'd

Similar to fold_closures, but applies the fold function to the outermost closures first. Unlike with fold_closures, only the closures reachable from p.start are considered.

val fold_children : 'c fold_blocs
val fold_children_skip_try_body : 'c fold_blocs
val poptraps : block Addr.Map.t -> Addr.t -> Addr.Set.t
val return_values : program -> Var.Set.t Var.Map.t
val traverse : fold_blocs_poly -> (Addr.t -> 'c -> 'c) -> Addr.t -> block Addr.Map.t -> 'c -> 'c
val preorder_traverse : fold_blocs_poly -> (Addr.t -> 'c -> 'c) -> Addr.t -> block Addr.Map.t -> 'c -> 'c
val last_instr : instr list -> instr option

Last instruction of a block body, ignoring events

val used_blocks : program -> Stdlib.BitSet.t
val prepend : program -> instr list -> program
val empty : program
val compact : program -> program
val is_empty : program -> bool
val equal : program -> program -> bool
val print_diff : program -> program -> unit
val check_updates : name:string -> program -> program -> updates:int -> unit
val invariant : program -> unit
val cont_equal : cont -> cont -> bool
val cont_compare : cont -> cont -> int