---
name: "Targetint"
section: "3o"
platform: "linux"
package: "ocaml"
version: "5.5.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Targetint"
---

# Targetint(3o)

Target processor-native integers.

## NAME

Targetint - Target processor-native integers.

## Module

Module   Targetint

## Documentation

Module **Targetint**\
  :  **sig end**

Target processor-native integers.

This module provides operations on the type of signed 32-bit integers (on 32-bit target platforms) or signed 64-bit integers (on 64-bit target platforms). This integer type has exactly the same width as that of a pointer type in the C compiler.  All arithmetic operations over are taken modulo 2^32 or 2^64 depending on the word size of the target architecture.

Warning: this module is unstable and part of **Compiler\_libs** .

*type t*

The type of target integers.

*val zero* :  **t**

The target integer 0.

*val one* :  **t**

The target integer 1.

*val minus\_one* :  **t**

The target integer -1.

*val neg* :  **t -\> t**

Unary negation.

*val add* :  **t -\> t -\> t**

Addition.

*val sub* :  **t -\> t -\> t**

Subtraction.

*val mul* :  **t -\> t -\> t**

Multiplication.

*val div* :  **t -\> t -\> t**

Integer division.  Raise  **Division\_by\_zero** if the second argument is zero.  This division rounds the real quotient of its arguments towards zero, as specified for  **(/)** .

*val unsigned\_div* :  **t -\> t -\> t**

Same as  **Targetint.div** , except that arguments and result are interpreted as     unsigned integers.

*val rem* :  **t -\> t -\> t**

Integer remainder.  If  **y** is not zero, the result of  **Targetint.rem x y** satisfies the following properties: **Targetint.zero \<= Nativeint.rem x y \< Targetint.abs y** and **x = Targetint.add (Targetint.mul (Targetint.div x y) y)**\
                       **(Targetint.rem x y)** . If  **y = 0** ,  **Targetint.rem x y** raises  **Division\_by\_zero** .

*val unsigned\_rem* :  **t -\> t -\> t**

Same as  **Targetint.rem** , except that arguments and result are interpreted as     unsigned integers.

*val succ* :  **t -\> t**

Successor. **Targetint.succ x** is  **Targetint.add x Targetint.one** .

*val pred* :  **t -\> t**

Predecessor. **Targetint.pred x** is  **Targetint.sub x Targetint.one** .

*val abs* :  **t -\> t**

**abs x** is the absolute value of  **x** . On  **min\_int** this is  **min\_int** itself and thus remains negative.

*val size* :  **int**

The size in bits of a target native integer.

*val max\_int* :  **t**

The greatest representable target integer, either 2^31 - 1 on a 32-bit platform, or 2^63 - 1 on a 64-bit platform.

*val min\_int* :  **t**

The smallest representable target integer, either -2^31 on a 32-bit platform, or -2^63 on a 64-bit platform.

*val logand* :  **t -\> t -\> t**

Bitwise logical and.

*val logor* :  **t -\> t -\> t**

Bitwise logical or.

*val logxor* :  **t -\> t -\> t**

Bitwise logical exclusive or.

*val lognot* :  **t -\> t**

Bitwise logical negation.

*val shift\_left* :  **t -\> int -\> t**

**Targetint.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  **32** on a 32-bit platform and **64** on a 64-bit platform.

*val shift\_right* :  **t -\> int -\> t**

**Targetint.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.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 of\_int* :  **int -\> t**

Convert the given integer (type  **int** ) to a target integer (type  **t** ), module the target word size.

*val of\_int\_exn* :  **int -\> t**

Convert the given integer (type  **int** ) to a target integer (type  **t** ).  Raises a fatal error if the conversion is not exact.

*val to\_int* :  **t -\> int**

Convert the given target integer (type  **t** ) to an integer (type  **int** ).  The high-order bit is lost during the conversion.

*val of\_float* :  **float -\> t**

Convert the given floating-point number to a target 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.min\_int** ,  **Targetint.max\_int** \].

*val to\_float* :  **t -\> float**

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

*val of\_int32* :  **int32 -\> t**

Convert the given 32-bit integer (type  **int32** ) to a target integer.

*val to\_int32* :  **t -\> int32**

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

*val of\_int64* :  **int64 -\> t**

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

*val to\_int64* :  **t -\> int64**

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

*val of\_string* :  **string -\> t**

Convert the given string to a target integer. The string is read in decimal (by default) or in hexadecimal, octal or binary if the string begins with  **0x** ,  **0o** or  **0b** respectively. Raise  **Failure "int\_of\_string"** if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type  **nativeint** .

*val to\_string* :  **t -\> string**

Return the string representation of its argument, in decimal.

*val compare* :  **t -\> t -\> int**

The comparison function for target integers, with the same specification as **compare** .  Along with the type  **t** , this function  **compare** allows the module  **Targetint** to be passed as argument to the functors **Set.Make** and  **Map.Make** .

*val unsigned\_compare* :  **t -\> t -\> int**

Same as  **Targetint.compare** , except that arguments are interpreted as unsigned integers.

*val equal* :  **t -\> t -\> bool**

The equal function for target ints.

*type repr* =\
  \| Int32 **of** **int32**\
  \| Int64 **of** **int64**

*val repr* :  **t -\> repr**

The concrete representation of a native integer.

*val print* :  **Format.formatter -\> t -\> unit**

Print a target integer to a formatter.