package ocaml-base-compiler

bind name arg fn is equivalent to let name = arg in fn name, or simply fn arg if arg is simple enough

Same as bind, but also treats loads from a variable as simple

Same as bind, but does not treat variables as simple

A null header with GC bits set to black

A constant equal to the tag for float arrays

block_header tag size creates a header with tag tag for a block of size size

Same as block_header, but with GC bits set to black

Closure headers of the given size

Infix header at the given offset

Header for a boxed float value

Header for an unboxed float array of the given size

Header for a string (or bytes) of the given length

Boxed integer headers

Closure info for a closure of given arity and distance to environment

Wrappers

Minimal/maximal OCaml integer values whose backend representation fits in a regular OCaml integer

Make an integer constant from the given integer (tags the integer)

Make a Cmm constant holding the given nativeint value. Uses Cconst_int instead of Cconst_nativeint when possible to preserve peephole optimisations.

Add an integer to the given expression

Increment/decrement of integers

Simplify the given expression knowing its last bit will be irrelevant

Simplify the given expression knowing its first bit will be irrelevant

Arithmetical operations on integers

Integer tagging. tag_int x = (x lsl 1) + 1

Integer untagging. untag_int x = (x asr 1)

Specific division operations for boxed integers

If-Then-Else expression mk_if_then_else dbg cond ifso_dbg ifso ifnot_dbg ifnot associates dbg to the global if-then-else expression, ifso_dbg to the then branch ifso, and ifnot_dbg to the else branch ifnot

Boolean negation

Integer and float comparison that returns int not bool

Loop construction (while true do expr done). Used to be represented as Cloop.

Exception raising

Convert a tagged integer into a raw integer with boolean meaning

Float boxing and unboxing

Complex number creation and access

Make the given expression return a unit value

Remove a trailing unit return if any

Non-atomic load of a mutable field

Atomic load. All atomic fields are mutable.

field_address ptr n dbg returns an expression for the address of the nth field of the block pointed to by ptr

get_field_gen mut ptr n dbg returns an expression for the access to the nth field of the block pointed to by ptr

set_field ptr n newval init dbg returns an expression for setting the nth field of the block pointed to by ptr to newval

Load a block's header

Same as get_header, but also clear all reserved bits of the result

Load a block's tag

Load a block's size

Check whether the given array is an array of regular OCaml values (as opposed to unboxed floats), from its header or pointer

Get the length of an array from its header Shifts by one bit less than necessary, keeping one of the GC colour bits, to save an operation when returning the length as a caml integer or when comparing it to a caml integer. Assumes that the reserved bits are clear (see get_header_masked)

For array_indexing ?typ log2size ptr ofs dbg : Produces a pointer to the element of the array ptr on the position ofs with the given element log2size log2 element size. ofs is given as a tagged int expression. The optional ?typ argument is the C-- type of the result. By default, it is Addr, meaning we are constructing a derived pointer into the heap. If we know the pointer is outside the heap (this is the case for bigarray indexing), we give type Int instead.

Array loads and stores unboxed_float_array_ref and float_array_ref differ in the boxing of the result; float_array_set takes an unboxed float

Lookup a method by its hash, using caml_get_public_method Arguments :

• obj : the object from which to lookup
• tag : the hash of the method name, as a tagged integer

Lookup a method by its offset in the method table Arguments :

• obj : the object from which to lookup
• lab : the position of the required method in the object's method array, as a tagged integer

Lookup and call a method using the method cache Arguments :

• obj : the object from which to lookup
• tag : the hash of the method name, as a tagged integer
• cache : the method cache array
• pos : the position of the cache entry in the cache array
• args : the additional arguments to the method call

Allocate a block of regular values with the given tag

Allocate a block of unboxed floats with the given tag

Generate a Ccheckbound term

check_bound safety access_size dbg length a2 k prefixes expression k with a check that reading access_size bits starting at position a2 in a string/bytes value of length length is within bounds, unless safety is Unsafe.

Sys.opaque_identity

Get the symbol for the generic application with n arguments, and ensure its presence in the set of defined symbols

If n is positive, get the symbol for the generic currying wrapper with n arguments, and ensure its presence in the set of defined symbols. Otherwise, do the same for the generic tuple wrapper with -n arguments.

bigarray_get unsafe kind layout b args dbg

• unsafe : if true, do not insert bound checks
• kind : see Lambda.bigarray_kind
• layout : see Lambda.bigarray_layout
• b : the bigarray to load from
• args : a list of tagged integer expressions, corresponding to the indices in the respective dimensions
• dbg : debugging information

bigarray_set unsafe kind layout b args newval dbg Same as bigarray_get, with newval the value being assigned

low_32 _ x is a value which agrees with x on at least the low 32 bits

Sign extend from 32 bits to the word size

Zero extend from 32 bits to the word size

Global symbols for the ops field of boxed integers

Box a given integer, without sharing of constants

Unbox a given boxed integer

Used to prepare 32-bit integers on 64-bit platforms for a lsr operation

unaligned_set size ptr idx newval dbg

unaligned_load size ptr idx dbg

box_sized size dbg exp

Return the n-th field of a float array (or float-only record), as an unboxed float

Int_as_pointer primitive

Raise primitive

Unary negation of an OCaml integer

Add a constant number to an OCaml integer

Add a constant number to an OCaml integer reference

Return the length of the array argument, as an OCaml integer

Byte swap primitive Operates on Cmm integers (unboxed values)

16-bit byte swap primitive Operates on Cmm integers (untagged integers)

setfield offset value_is_ptr init ptr value dbg

setfloatfield offset init ptr value dbg value is expected to be an unboxed floating point number

Operations on OCaml integers

Regular string/bytes access. Args: string/bytes, index

Load by chunk from string/bytes, bigstring. Args: string, index

Array access. Args: array, index

Same as setfield, except the offset is one of the arguments. Args: pointer (structure/array/...), index, value

Set the byte at the given offset to the given value. Args: bytes, index, value

Set the element at the given index in the given array to the given value. WARNING: if kind is Pfloatarray, then value is expected to be an _unboxed_ float. Otherwise, it is expected to be a regular caml value, including in the case where the array contains floats. Args: array, index, value

Set a chunk of data in the given bytes or bigstring structure. See also string_load and bigstring_load. Note: value is expected to be an unboxed number of the given size. Args: pointer, index, value

transl_isout h arg dbg

make_switch arg cases actions dbg : Generate a Cswitch construct, or optimize as a static table lookup when possible.

transl_int_switch loc arg low high cases default

transl_switch_clambda loc arg index cases

strmatch_compile dbg arg default cases

Adds a constant offset to a pointer (for infix access)

Direct application of a function via a symbol

Generic application of a function to one or several arguments. The mutable_flag argument annotates the loading of the code pointer from the closure. The Cmmgen code uses a mutable load by default, with a special case when the load is from (the first function of) the currently defined closure.

Method call : send kind met obj args dbg

• met is a method identifier, which can be a hashed variant or an index in obj's method table, depending on kind
• obj is the object whose method is being called
• args is the extra arguments to the method call (Note: I'm not aware of any way for the frontend to generate any arguments other than the cache and cache position)

Generate generic functions

Entry point

Generate the caml_globals table

Add references to the given symbols

Generate the caml_globals_map structure, as a marshalled string constant

Generate the caml_frametable table, referencing the frametables from the given compilation units

Generate the tables for data and code positions respectively of the given compilation units

Generate data for a predefined exception

Produce the data_item list corresponding to a symbol definition

emit_block symb white_header cont prepends to cont the header and symbol for the block. cont must already contain the fields of the block (and may contain additional data items afterwards).

Emit specific kinds of constant blocks as data items