ocaml_intrinsics v0.17.0 (latest)

type t = private nativeint

Native_pointer uses Nativeint to hold a pointer to a memory block allocated outside the OCaml heap. The pointer is not required to be aligned.

val ext_pointer_as_native_pointer : int -> t

ext_pointer_as_native_pointer p takes an int p that encodes a pointer to a memory block outside of the OCaml heap, decodes p by clearing the least significant bit of p, and boxes the result as nativeint. Unlike untagging, decoding p does not shift the bits of p.

val unsafe_of_value : 'a -> t

Reinterpret any 'a as a native pointer. The unboxed result will have the same bit representation as the input value. If 'a is a pointer to outside the OCaml heap, the result may be used with load or store operations.

val unsafe_to_value : t -> 'a

Reinterpret the unboxed contents of a native pointer as a value of any type. The result will have the same bit representation as the unboxed input pointer. The result must be a valid OCaml value: either an immediate or a pointer to an address with a valid OCaml header.

val load_untagged_int : t -> int

load_untagged_int t reads untagged int pointed to by t and returns the corresponding tagged int. This should only be used to read a value written by store_untagged_int. Otherwise, if the value has most significant bit set, it will be lost by tagging. To avoid it, use load_unboxed_nativeint and check before converting to int (should not allocate). Their native code C stub is the same.

val store_untagged_int : t -> int -> unit

store_untagged_int t d untags d and stores the result to the memory pointed to by t.

val load_unboxed_nativeint : t -> nativeint

load_unboxed_nativeint t reads unboxed nativeint pointed to by t and returns the corresponding (boxed) nativeint allocated on the OCaml heap.

val store_unboxed_nativeint : t -> nativeint -> unit

store_unboxed_nativeint t d stores the unboxed nativeint to the memory pointed to by t.

val load_unboxed_int64 : t -> int64

load_unboxed_int64 t reads unboxed int64 pointed to by t and returns the corresponding (boxed) int64 allocated on the OCaml heap.

val store_unboxed_int64 : t -> int64 -> unit

store_unboxed_int64 t d stores the unboxed int64 to the memory pointed to by t.

val load_unboxed_int32 : t -> int32

load_unboxed_int32 t reads unboxed int32 pointed to by t and returns the corresponding (boxed) int32 allocated on the OCaml heap.

val store_unboxed_int32 : t -> int32 -> unit

store_unboxed_int32 t d stores the unboxed int32 to the memory pointed to by t.

For float operations, the pointer must be aligned at least to the native integer machine width (meaning on 32-bit platforms, a 32-bit-aligned pointer is acceptable even though the width of the float is 64 bits).

val load_unboxed_float : t -> float

load_unboxed_float t reads the unboxed float pointed to by t. (If the result is not directly passed to another operation expecting an unboxed float, then it will be boxed.)

val store_unboxed_float : t -> float -> unit

store_unboxed_float t d stores the unboxed float to the memory pointed to by t.

Pointer arithmetic and comparisons

val difference_in_bytes : t -> t -> nativeint

difference_in_bytes start end subtracts start from end, assuming that both point to the same block of memory (such as an array). The result is the number of bytes, not a pointer.

val advance : t -> bytes:nativeint -> t

Adds n bytes to a pointer, resulting in another pointer.

val (=) : t -> t -> bool

Equal operator is defined for any two pointers. Inequality operators are only defined when both pointers point to the same block of memory (such as an array).

val (<>) : t -> t -> bool

val (<) : t -> t -> bool

val (>) : t -> t -> bool

val (<=) : t -> t -> bool

val (>=) : t -> t -> bool

module type Immediate_intf = sig ... end

Load and store immediate values. Intended for use with Int and Bool.

module Int : Immediate_intf with type V.t = Int.t

module Bool : Immediate_intf with type V.t = Bool.t

module Expert : sig ... end

package ocaml_intrinsics