Module Lambda

This is the same as Primitive.native_repr but with Repr_poly compiled away.

When accessing a flat float array, we need to know the mode which we should box the resulting float at.

When updating an array that might contain pointers, we need to know what mode they're at; otherwise, access is uniform.

Nullable value kinds allow the special Null value in addition to the values of its underlying type. Non_nullable only allows values of the underlying type.

A well-formed function parameter list is of the form G @ L @ [ Final_arg ], where the values of G and L are of the form More_args { partial_mode }, where partial_mode has locality Global in G and locality Local in L.

nlocal is defined as follows:

• if

  |L| > 0

  , then

  nlocal = |L| + 1

  .

• if

  |L| = 0

  , * if the function returns at mode local, the final arg has mode local, or the function itself is allocated locally, then

  nlocal = 1

  . * otherwise,

  nlocal = 0

  .

The debug_uid values track typed-tree level identifiers that are then passed down to the lower level IRs and eventually emitted into dwarf output. WARNING: Unlike the name sugggests, these identifiers are not always unique. Instead, in many cases, we use debug_uid_none below, and multiple variables at the level of Lambda or below can use the same debug_uid.

debug_uid_none should be used for those identifiers that are not user visible (i.e., that are created internally in the compiler and do not mean anything to users writing OCaml code).

The lambda type is shared across multiple phases of compilation, where some constructors are invalid at different stages.

Compilation looks like:

typedtree
---transl--> tlambda
--fracture-> slambda
----eval---> rawlambda
---simplif-> lambda

where tlambda, slambda, rawlambda, and lambda are all represented using this type.

Most constructors are valid at all stages, the constructors that aren't document this. The only other difference is that layout can contain variables before eval (tlambda and slambda) and not after eval (rawlambda and lambda).

dummy_constant produces a placeholder value with a recognizable bit pattern (currently 0xBBBB in its tagged form)

iter_head_constructor f lam apply f to only the first level of sub expressions of lam. It does not recursively traverse the expression.

Callers should note that you will need to handle stage specific constructors (Lsplice, etc) depending on what stage you are calling this from.

Same as iter_head_constructor, but use a different callback for sub-terms which are in tail position or not.

Callers should note that you will need to handle stage specific constructors (Lsplice, etc) depending on what stage you are calling this from.

Translate a value from a persistent module. For instance:

  transl_internal_value "CamlinternalLazy" "force"

subst update_env ?freshen_bound_variables s lt applies a substitution s to the lambda-term lt.

Assumes that the image of the substitution is out of reach of the bound variables of the lambda-term (no capture).

update_env is used to refresh the environment contained in debug events.

freshen_bound_variables, which defaults to false, freshens the bound variables within lt.

A version of subst specialized for the case where we're just renaming idents.

Duplicate a term, freshening all locally-bound identifiers.

Bottom-up rewriting, applying the function on each node from the leaves to the root.

Apply the given transformation on the function's body

Rewrite each immediate sub-term with the function.

Maximal number of parameters for a function, or in other words, maximal length of the params list of a lfunction record. This is unlimited (max_int) for bytecode, but limited (currently to 126) for native code.

Whether and where a primitive may allocate. Some Alloc_local permits both options: that is, primitives that may allocate on both the GC heap and locally report this value.

This treats projecting an unboxed float from a float record as non-allocating, which is a lie for the bytecode backend (where unboxed floats are boxed). Presently this function is only used for stack allocation, which doesn't happen in bytecode. If that changes, or if we want to use this for another purpose in bytecode, it will need to be revised.

Like primitive_may_allocate, for external calls.

Helpers for module block accesses. Module accesses are always immutable, except in translobj where the method cache is stored in a mutable module field.

Returns the element at the given path in a mixed block shape. The path is a list of field indices for navigating into nested products.

Immediate if a type of scannable jkind is GC-ignorable based on its provided externality, and Pointer otherwise.

Whether there exists a non-value before a value

The mode will be discarded if unnecessary for the given array_kind

The mode will be discarded if unnecessary for the given array_kind

Any mode information in the given array_set_kind is ignored. Any mode in the return value always comes from the locality_mode parameter.

This function currently assumes a 64-bit target.

A tagged immediate.

See the comment on the Pphys_equal primitive. This can be applied to any arguments of kind value.

This is ONLY for comparing scalar integral values.

It may NOT be applied to arbitrary arguments of kind value, as it can cause flambda2 to infer that the arguments are always both tagged immediates. Use phys_equal to compare values when either of them might not be an immediate.