#### 5.1.2 Defining Builtin Types Using Builtin Type Descriptors ¶

This is the method used by Sun’s `acc` for defining builtin types. These are the type descriptors to define builtin types:

`b signed char-flag width ; offset ; nbits ;`

  Define an integral type. signed is ‘`u`’ for unsigned or ‘`s`’ for signed. char-flag is ‘`c`’ which indicates this is a character type, or is omitted. I assume this is to distinguish an integral type from a character type of the same size, for example it might make sense to set it for the C type `wchar_t` so the debugger can print such variables differently (Solaris does not do this). Sun sets it on the C types `signed char` and `unsigned char` which arguably is wrong. width and offset appear to be for small objects stored in larger ones, for example a `short` in an `int` register. width is normally the number of bytes in the type. offset seems to always be zero. nbits is the number of bits in the type.

  Note that type descriptor ‘`b`’ used for builtin types conflicts with its use for Pascal space types (see Miscellaneous Types); they can be distinguished because the character following the type descriptor will be a digit, ‘`(`’, or ‘`-`’ for a Pascal space type, or ‘`u`’ or ‘`s`’ for a builtin type.

`w`

  Documented by AIX to define a wide character type, but their compiler actually uses negative type numbers (see Negative Type Numbers).

`R fp-type ; bytes ;`

  Define a floating point type. fp-type has one of the following values:

  `1 (NF_SINGLE)`

    IEEE 32-bit (single precision) floating point format.

  `2 (NF_DOUBLE)`

    IEEE 64-bit (double precision) floating point format.

  `3 (NF_COMPLEX)`
  `4 (NF_COMPLEX16)`
  `5 (NF_COMPLEX32)`

    These are for complex numbers. A comment in the GDB source describes them as Fortran `complex`, `double complex`, and `complex*16`, respectively, but what does that mean? (i.e., Single precision? Double precision?).

  `6 (NF_LDOUBLE)`

    Long double. This should probably only be used for Sun format `long double`, and new codes should be used for other floating point formats (`NF_DOUBLE` can be used if a `long double` is really just an IEEE double, of course).

  bytes is the number of bytes occupied by the type. This allows a debugger to perform some operations with the type even if it doesn’t understand fp-type.

`g type-information ; nbits`

  Documented by AIX to define a floating type, but their compiler actually uses negative type numbers (see Negative Type Numbers).

`c type-information ; nbits`

  Documented by AIX to define a complex type, but their compiler actually uses negative type numbers (see Negative Type Numbers).

The C `void` type is defined as a signed integral type 0 bits long:

    .stabs "void:t19=bs0;0;0",128,0,0,0

The Solaris compiler seems to omit the trailing semicolon in this case. Getting sloppy in this way is not a swift move because if a type is embedded in a more complex expression it is necessary to be able to tell where it ends.

I’m not sure how a boolean type is represented.