31-bit computing

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "31-bit computing" – news · newspapers · books · scholar · JSTOR (May 2023) (Learn how and when to remove this message)

In computer architecture, 31-bit integers, memory addresses, or other data units are those that are 31 bits wide.

In 1983, IBM introduced 31-bit addressing in the System/370-XA mainframe architecture as an upgrade to the 24-bit physical and virtual,^[1] and transitional 24-bit-virtual/26-bit physical,^[2][3] addressing in System/370.^[4][5] This enhancement allowed address spaces to be 128 times larger, permitting programs to address memory above 16 MB (referred to as "above the line").^[6][1] Support for COBOL, FORTRAN and later on Linux/390 was included.

In the early 1980s, the Motorola 68012 was introduced; it had 32-bit data and address registers, as did the Motorola 68010, but instead of providing the lower 24 bits of an address, it did so for all but bit 30 on the address pins.^[7]

The Librascope LGP-30 was an early off-the-shelf computer. The LGP-30 was first manufactured in 1956,^[8] at a retail price of $47,000,^{[citation needed]} equivalent to $560,000 in 2025.^[9]

It was a binary, 31-bit word computer with a 4096-word drum memory. There were 32 bit locations per drum word, but only 31 were used, permitting a "restoration of magnetic flux in the head" at the 32nd bit time. The number of vacuum tubes was minimized by using solid-state diode logic, a bit-serial architecture and multiple use of each of its 15 flip-flops.

The LGP-30 was commonly referred to as a desk computer. Its height, width, and depth, excluding the typewriter shelf, was 33 by 44 by 26 inches (84 by 112 by 66 cm). It weighed about 800 pounds (360 kg), and was mounted on sturdy casters which facilitated moving the unit.

In the System/360, other than the 360/67, and early System/370 architectures, the general-purpose registers were 32 bits wide, the machine did 32-bit arithmetic operations, and addresses were always stored in 32-bit words, so the architecture was considered 32-bit, but the machines ignored the top 8 bits of the address resulting in 24-bit addressing.

With the System/370-XA architecture and the IBM Enterprise Systems Architecture, in addition to a 24-bit addressing mode for compatibility with older applications, there is a 31-bit addressing mode, in which only the high order bit (bit 0) in the word is ignored for addressing. An exception is that mode-switching instructions also use bit 0. There were at least two reasons that IBM did not implement the 32-bit addressing of the 360/67

1. The loop control instructions BXH and BXLE did signed comparisons.
2. Much of the existing software used bit 0 as an end-of-list indicator.^[10]

The 64-bit z/Architecture also supports 24-bit and 31-bit addressing modes for compatibility with older applications.

Interpreters for Ruby and Smalltalk languages use the lowest bit to tell whether a value is an unboxed integer or not. This means that on 32-bit machines (or 16-bit machines with 32-bit pointers), 31-bit integers are unboxed. In case of overflow, the result is fit into a boxed object, which means that it has to be allocated and garbage-collected. Thus if you have 32-bit values that don't fit in the 31-bit signed format, they will be very inefficient in those interpreters. Same goes with 63-bit unboxed integers on 64-bit computers. Similar designs may be found in LISP and some of the other languages whose variables can take values of any type. In some cases, there was hardware support for this kind of design: see Tagged architecture and Lisp machine.