I think the time has arrived for a new scalar type in C, which for want of a better name I shall call the `compendium`

type.

On today’s processors a compendium type behaves a lot like an integer type, except that nobody really wants to include it in the list of supported integer types, e.g., 128-bit scalars.

Why is a new scalar type needed? The Standard supports extended integer types, why not treat a scalar object that supports integer arithmetic as an integer type?

The C Standard says (section 6.2.5 Types):

“There are five standard signed integer types, designated as `signed char`

, `short int`

, `int`

, `long int`

, and `long long int`

. (These and other types may be designated in several additional ways, as described in 6.7.2.) There may also be implementation-defined extended signed integer types.38) The standard and extended signed integer types are collectively called signed integer types.39)”

There is corresponding wording for unsigned integer types.

The standard header

allows implementations to define a whole menagerie of integer types: section 7.20.1.1 Exact-width integer types

“The typedef name `int`

designates a signed integer type with width *N*_t*N*, no padding bits, and a two’s complement representation. Thus, `int8_t`

denotes such a signed integer type with a width of exactly 8 bits.”

This all sounds very feasible, but there is a catch. The Standard defines a greatest-width integer type, section 7.20.1.5 Greatest-width integer types

“The following type designates a signed integer type capable of representing any value of any signed integer type:

`intmax_t`

”

and various library functions have an argument type `intmax_t`

(there is also an `uintmax_t`

).

An ‘extra-large’ integer type is not something that can just sit there, in the list of available integer types, waiting to be used. Preprocessor arithmetic and a variety of library are based around the type `intmax_t`

. An extra-large integer type would have a very visible impact on all developers, many of whom would want to ignore it.

GCC supports 128-bit integers, e.g., `__int128`

. But some magic pixie dust is involved, this type has no connection with `intmax_t`

.

What do developers do with these 128- and 256-bit scalar objects? Evaluating graphics algorithms, hashes and cryptographic calculations are obvious candidates; yes, perhaps even calculations involving integers that require this many bits. I have not seen any analysis of the uses of this kind of wide-integer-like type.

Extra-wide scalar types have a variety of uses and the term `compendium`

type, captures this. Hardware support for such extra-width types is growing, with vendors looking to fill major niches.

Contorting existing wording, in the Standard, so accommodate these extra-wide types within the existing integer type machinery is a short term solution. Work on the upcoming revision of the C Standard should either do nothing and allow vendors to take the approach currently used by GCC, or create a new scalar type (perhaps using a TR).