jon.recoil.org

Module Flambda2_numbers.Target_ocaml_int

Operations using the semantics of the OCaml type "int" on the target machine. That is to say, 31-bit arithmetic on 32-bit targets; and 63-bit arithmetic on 64-bit targets.

type t
include Flambda2_algorithms.Container_types.S with type t := Flambda2_numbers.Target_ocaml_int.t
include Flambda2_algorithms.Container_types_intf.Thing with type t := Flambda2_numbers.Target_ocaml_int.T.t
include Stdlib.Hashtbl.HashedType with type t := Flambda2_numbers.Target_ocaml_int.T.t

The equality predicate used to compare keys.

A hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include

  • ((=), hash) for comparing objects by structure (provided objects do not contain floats)
  • ((fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly
  • ((==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).
include Stdlib.Map.OrderedType with type t := Flambda2_numbers.Target_ocaml_int.T.t

A total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.

The minimum integer representable on the target.

The maximum integer representable on the target.

The OCaml integer -1

The OCaml integer 0.

The OCaml integer 1.

The OCaml integer 10.

The OCaml integer 0xff.

The set

1, 0, 1

}

.

Boolean values.

Comparison functions.

val bottom_byte_to_int : Flambda2_numbers.Target_ocaml_int.t -> int

Returns the 8 least significant bits of the OCaml integer as a host caml integer (cannot overflow).

Returns the OCaml integer corresponding to the ASCII code of the given character.

Convert the given integer (type int) to a OCaml integer (type t), modulo the target word size minus one (for the tag bit).

Returns None iff the given int cannot be represented as a target "int"-width integer, else returns the same as of_int.

Convert the given OCaml integer (type t) to an integer (type int), modulo the int size, i.e. high-order bits are lost during the conversion.

val to_int_option : Flambda2_numbers.Target_ocaml_int.t -> int option

Convert the given OCaml integer (type t) to an integer (type int). Returns None if the original OCaml integer does not fit into an integer

val to_int_exn : Flambda2_numbers.Target_ocaml_int.t -> int

Convert the given OCaml integer (type t) to an integer (type int).

  • raises Fatal_error

    if the original OCaml integer does not fit into an integer

Convert the given 32-bit integer (type int32) to a OCaml integer, modulo the size of a OCaml integer.

val to_int32 : Flambda2_numbers.Target_ocaml_int.t -> int32

Convert the given OCaml integer to a 32-bit integer (type int32). On 64-bit platforms, the 64-bit native integer is taken modulo 232, i.e. the top 32 bits are lost. On 32-bit platforms, the conversion is exact.

Convert the given 64-bit integer (type int64) to a target native integer, modulo the size of a OCaml integer.

val to_int64 : Flambda2_numbers.Target_ocaml_int.t -> int64

Convert the given OCaml integer to a 64-bit integer (type int64).

Convert the given target native integer (type Targetint_32_64.t) to an OCaml integer, modulo the size of an OCaml integer.

Convert the given OCaml integer (type t) to a target native integer (type Targetint_32_64.t).

Convert the given floating-point number to an OCaml integer, discarding the fractional part (truncate towards 0). The result of the conversion is undefined if, after truncation, the number is outside the range [Targetint_31_63.min_value, Targetint_31_63.max_value].

val to_float : Flambda2_numbers.Target_ocaml_int.t -> float

Convert the given OCaml integer to a floating-point number.

Unary negation.

val get_least_significant_16_bits_then_byte_swap : Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t

Extract the least significant 16 bits from the given OCaml integer, exchange the order of the two bytes extracted, then form a new target integer by zero-extending those two bytes.

Addition.

Subtraction.

Multiplication.

val mod_ : Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t

Integer division and modulo. Raise Division_by_zero if the second argument is zero. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).

val and_ : Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t

Bitwise logical and.

val or_ : Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t -> Flambda2_numbers.Target_ocaml_int.t

Bitwise logical or.

Bitwise logical exclusive or.

shift_left x y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= bitsize, where bitsize is 31 on a 32-bit platform and 63 on a 64-bit platform.

Targetint_32_64.shift_right x y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= bitsize.

Targetint_32_64.shift_right_logical x y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= bitsize.

Returns the smaller integer.

Returns the larger integer.

val is_non_negative : Flambda2_numbers.Target_ocaml_int.t -> bool
module Pair : sig ... end