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 := t

module T : Flambda2_algorithms.Container_types_intf.Thing with type t = t

include Flambda2_algorithms.Container_types_intf.Thing with type t := T.t

include Hashtbl.HashedType with type t := T.t

val equal : T.t -> T.t -> bool

The equality predicate used to compare keys.

val hash : T.t -> int

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 Map.OrderedType with type t := T.t

val compare : T.t -> T.t -> int

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.

val print : Format.formatter -> T.t -> unit

module Set : Flambda2_algorithms.Container_types_intf.Set with type elt = t

module Map : 
  Flambda2_algorithms.Container_types_intf.Map
    with type key = t
     and module Set = Set

val machine_width : t -> Target_system.Machine_width.t

val min_value : Target_system.Machine_width.t -> t

The minimum integer representable on the target.

val max_value : Target_system.Machine_width.t -> t

The maximum integer representable on the target.

val minus_one : Target_system.Machine_width.t -> t

The OCaml integer -1

val zero : Target_system.Machine_width.t -> t

The OCaml integer 0.

val one : Target_system.Machine_width.t -> t

The OCaml integer 1.

val ten : Target_system.Machine_width.t -> t

The OCaml integer 10.

val hex_ff : Target_system.Machine_width.t -> t

The OCaml integer 0xff.

val zero_one_and_minus_one : Target_system.Machine_width.t -> Set.t

The set containing -1, 0, and 1.

val bool : Target_system.Machine_width.t -> bool -> t

Boolean values.

val bool_true : Target_system.Machine_width.t -> t

val bool_false : Target_system.Machine_width.t -> t

val all_bools : Target_system.Machine_width.t -> Set.t

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

Comparison functions.

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

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

val bottom_byte_to_int : t -> int

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

val of_char : Target_system.Machine_width.t -> char -> t

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

val of_int : Target_system.Machine_width.t -> int -> t

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

val of_int_option : Target_system.Machine_width.t -> int -> t option

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

val to_int : t -> 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 : 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 : 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

val of_int32 : Target_system.Machine_width.t -> int32 -> t

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

val to_int32 : 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 2³², i.e. the top 32 bits are lost. On 32-bit platforms, the conversion is exact.

val of_int64 : Target_system.Machine_width.t -> int64 -> t

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

val to_int64 : t -> int64

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

val of_targetint : Target_system.Machine_width.t -> Targetint_32_64.t -> t

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

val to_targetint : Target_system.Machine_width.t -> t -> Targetint_32_64.t

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

val of_float : Target_system.Machine_width.t -> float -> 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 : t -> float

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

val neg : t -> t

Unary negation.

val get_least_significant_16_bits_then_byte_swap : t -> 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.

val add : t -> t -> t

Addition.

val sub : t -> t -> t

Subtraction.

val mul : t -> t -> t

Multiplication.

val mod_ : t -> t -> t

val div : t -> t -> 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_ : t -> t -> t

Bitwise logical and.

val or_ : t -> t -> t

Bitwise logical or.

val xor : t -> t -> t

Bitwise logical exclusive or.

val shift_left : t -> int -> t

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.

val shift_right : t -> int -> t

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.

val shift_right_logical : t -> int -> t

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.

val min : t -> t -> t

Returns the smaller integer.

val max : t -> t -> t

Returns the larger integer.

val is_non_negative : t -> bool

val of_int8 : Target_system.Machine_width.t -> Numeric_types.Int8.t -> t

val of_int16 : Target_system.Machine_width.t -> Numeric_types.Int16.t -> t

module Pair : sig ... end

val cross_product : Set.t -> Set.t -> Pair.Set.t

Module Flambda2_numbers.Target_ocaml_int

Module `Flambda2_numbers.Target_ocaml_int`