ocaml-base-compiler 4.13.1

type machtype_component =

| Val
| Addr
| Int
| Float

type machtype = machtype_component array

val typ_void : machtype

val typ_val : machtype

val typ_addr : machtype

val typ_int : machtype

val typ_float : machtype

val lub_component : 
  machtype_component ->
  machtype_component ->
  machtype_component

Least upper bound of two machtype_components.

val ge_component : machtype_component -> machtype_component -> bool

Returns true iff the first supplied machtype_component is greater than or equal to the second under the relation used by lub_component.

type exttype =

| XInt
(*
r OCaml value, word-sized integer
*)
| XInt32
(*
r 32-bit integer
*)
| XInt64
(*
r 64-bit integer
*)
| XFloat
(*
r double-precision FP number
*)

A variant of machtype used to describe arguments to external C functions

val machtype_of_exttype : exttype -> machtype

val machtype_of_exttype_list : exttype list -> machtype

type integer_comparison = Lambda.integer_comparison =

| Ceq
| Cne
| Clt
| Cgt
| Cle
| Cge

val negate_integer_comparison : integer_comparison -> integer_comparison

val swap_integer_comparison : integer_comparison -> integer_comparison

type float_comparison = Lambda.float_comparison =

| CFeq
| CFneq
| CFlt
| CFnlt
| CFgt
| CFngt
| CFle
| CFnle
| CFge
| CFnge

val negate_float_comparison : float_comparison -> float_comparison

val swap_float_comparison : float_comparison -> float_comparison

type label = int

val new_label : unit -> label

val set_label : label -> unit

val cur_label : unit -> label

type rec_flag =

| Nonrecursive
| Recursive

type phantom_defining_expr =

| Cphantom_const_int of Targetint.t
(*
The phantom-let-bound variable is a constant integer. The argument must be the tagged representation of an integer within the range of type int on the target. (Analogously to Cconst_int.)
*)
| Cphantom_const_symbol of string
(*
The phantom-let-bound variable is an alias for a symbol.
*)
| Cphantom_var of Backend_var.t
(*
The phantom-let-bound variable is an alias for another variable. The aliased variable must not be a bound by a phantom let.
*)
| Cphantom_offset_var of {
1. var : Backend_var.t;
2. offset_in_words : int;
}
(*
The phantom-let-bound-variable's value is defined by adding the given number of words to the pointer contained in the given identifier.
*)
| Cphantom_read_field of {
1. var : Backend_var.t;
2. field : int;
}
(*
The phantom-let-bound-variable's value is found by adding the given number of words to the pointer contained in the given identifier, then dereferencing.
*)
| Cphantom_read_symbol_field of {
1. sym : string;
2. field : int;
}
(*
As for Uphantom_read_var_field, but with the pointer specified by a symbol.
*)
| Cphantom_block of {
1. tag : int;
2. fields : Backend_var.t list;
}
(*
The phantom-let-bound variable points at a block with the given structure.
*)

type memory_chunk =

| Byte_unsigned
| Byte_signed
| Sixteen_unsigned
| Sixteen_signed
| Thirtytwo_unsigned
| Thirtytwo_signed
| Word_int
| Word_val
| Single
| Double
| Double_u

and operation =

| Capply of machtype
| Cextcall of string * machtype * exttype list * bool
(*
The machtype is the machine type of the result. The exttype list describes the unboxing types of the arguments. An empty list means "all arguments are machine words XInt".
*)
| Cload of memory_chunk * Asttypes.mutable_flag
| Calloc
| Cstore of memory_chunk * Lambda.initialization_or_assignment
| Caddi
| Csubi
| Cmuli
| Cmulhi
| Cdivi
| Cmodi
| Cand
| Cor
| Cxor
| Clsl
| Clsr
| Casr
| Ccmpi of integer_comparison
| Caddv
| Cadda
| Ccmpa of integer_comparison
| Cnegf
| Cabsf
| Caddf
| Csubf
| Cmulf
| Cdivf
| Cfloatofint
| Cintoffloat
| Ccmpf of float_comparison
| Craise of Lambda.raise_kind
| Ccheckbound
| Copaque

and expression =

| Cconst_int of int * Debuginfo.t
| Cconst_natint of nativeint * Debuginfo.t
| Cconst_float of float * Debuginfo.t
| Cconst_symbol of string * Debuginfo.t
| Cvar of Backend_var.t
| Clet of Backend_var.With_provenance.t * expression * expression
| Clet_mut of Backend_var.With_provenance.t * machtype * expression * expression
| Cphantom_let of Backend_var.With_provenance.t * phantom_defining_expr option * expression
| Cassign of Backend_var.t * expression
| Ctuple of expression list
| Cop of operation * expression list * Debuginfo.t
| Csequence of expression * expression
| Cifthenelse of expression * Debuginfo.t * expression * Debuginfo.t * expression * Debuginfo.t
| Cswitch of expression * int array * (expression * Debuginfo.t) array * Debuginfo.t
| Ccatch of rec_flag * (int * (Backend_var.With_provenance.t * machtype) list * expression * Debuginfo.t) list * expression
| Cexit of int * expression list
| Ctrywith of expression * Backend_var.With_provenance.t * expression * Debuginfo.t

Every basic block should have a corresponding Debuginfo.t for its beginning.

type codegen_option =

| Reduce_code_size
| No_CSE

type fundecl = {

fun_name : string;
fun_args : (Backend_var.With_provenance.t * machtype) list;
fun_body : expression;
fun_codegen_options : codegen_option list;
fun_dbg : Debuginfo.t;

}

type data_item =

| Cdefine_symbol of string
| Cglobal_symbol of string
| Cint8 of int
| Cint16 of int
| Cint32 of nativeint
| Cint of nativeint
| Csingle of float
| Cdouble of float
| Csymbol_address of string
| Cstring of string
| Cskip of int
| Calign of int

type phrase =

| Cfunction of fundecl
| Cdata of data_item list

val ccatch : 
  (int
   * (Backend_var.With_provenance.t * machtype) list
   * expression
   * expression
   * Debuginfo.t) ->
  expression

val reset : unit -> unit

val iter_shallow_tail : (expression -> unit) -> expression -> bool

Either apply the callback to all immediate sub-expressions that can produce the final result for the expression and return true, or do nothing and return false. Note that the notion of "tail" sub-expression used here does not match the one used to trigger tail calls; in particular, try...with handlers are considered to be in tail position (because their result become the final result for the expression).

val map_tail : (expression -> expression) -> expression -> expression

Apply the transformation to an expression, trying to push it to all inner sub-expressions that can produce the final result. Same disclaimer as for iter_shallow_tail about the notion of "tail" sub-expression.

val map_shallow : (expression -> expression) -> expression -> expression

Apply the transformation to each immediate sub-expression.

package ocaml-base-compiler