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 section 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 section 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 precison?).

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 section Negative Type Numbers).

c type-information ; nbits

Documented by AIX to define a complex type, but their compiler actually uses negative type numbers (see section 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.

Go to the first, previous, next, last section, table of contents.