GHC's primitive types and operations. Use GHC.Exts from the base package instead of importing this module directly.

Haskell98 specifies that signed integers (type Int) must contain at least 30 bits. GHC always implements Int using the primitive type Int#, whose size equals the MachDeps.h constant WORD_SIZE_IN_BITS. This is normally set based on the config.h parameter SIZEOF_HSWORD, i.e., 32 bits on 32-bit machines, 64 bits on 64-bit machines. However, it can also be explicitly set to a smaller number than 64, e.g., 62 bits, to allow the possibility of using tag bits. Currently GHC itself has only 32-bit and 64-bit variants, but 61, 62, or 63-bit code can be exported as an external core file for use in other back ends. 30 and 31-bit code is no longer supported.

GHC also implements a primitive unsigned integer type Word# which always has the same number of bits as Int#.

In addition, GHC supports families of explicit-sized integers and words at 8, 16, 32, and 64 bits, with the usual arithmetic operations, comparisons, and a range of conversions. The 8-bit and 16-bit sizes are always represented as Int# and Word#, and the operations implemented in terms of the primops on these types, with suitable range restrictions on the results (using the narrow$n$Int# and narrow$n$Word# families of primops. The 32-bit sizes are represented using Int# and Word# when WORD_SIZE_IN_BITS $geq$ 32; otherwise, these are represented using distinct primitive types Int32# and Word32#. These (when needed) have a complete set of corresponding operations; however, nearly all of these are implemented as external C functions rather than as primops. Exactly the same story applies to the 64-bit sizes. All of these details are hidden under the PrelInt and PrelWord modules, which use #if-defs to invoke the appropriate types and operators.

Word size also matters for the families of primops for indexing/reading/writing fixed-size quantities at offsets from an array base, address, or foreign pointer. Here, a slightly different approach is taken. The names of these primops are fixed, but their types vary according to the value of WORD_SIZE_IN_BITS. For example, if word size is at least 32 bits then an operator like indexInt32Array# has type ByteArray# -> Int# -> Int#; otherwise it has type ByteArray# -> Int# -> Int32#. This approach confines the necessary #if-defs to this file; no conditional compilation is needed in the files that expose these primops.

Finally, there are strongly deprecated primops for coercing between Addr#, the primitive type of machine addresses, and Int#. These are pretty bogus anyway, but will work on existing 32-bit and 64-bit GHC targets; they are completely bogus when tag bits are used in Int#, so are not available in this case.

Operations on 31-bit characters.

Operations on native-size integers (32+ bits).