Click above to get retro games delivered to your door ever month!

There are times when a value may be stored in more than one register.  For
example, a 32-bit "long" integer value may be stored in the register pair
DX:AX.  We require a mechanism for grouping registers to represent a single
quantity for use in expressions.

We define the term "register aggregate" as any grouping of registers to form
a single unit.  An aggregate is specified by placing register names in
brackets in order from most significant to least significant.  Any aggregate
may be specified as long as it forms an 8, 16, 32 or 64-bit quantity.  The
following are examples of some of the many aggregates that can be formed.

Example:

     8-bit    [al]
     16-bit   [ah al]
     16-bit   [bl ah]
     16-bit   [ax]
     32-bit   [dx ax]
     32-bit   [dh dl ax]
     32-bit   [dh dl ah al]
     32-bit   [ds di]
     64-bit   [ax bx cx dx]
     64-bit   [edx eax]       (386/486/Pentium only)

In some cases, the specified aggregate may be equivalent to a register.  For
example, the aggregates "[ah al]" and "[ax]" are equivalent to "ax".

The default type for 8-bit, 16-bit, and 32-bit aggregates is integer.  The
default type for 64-bit aggregates is double-precision floating-point.  To
force the debugger into treating a 32-bit aggregate as single-precision
floating-point, the type coercion operator "[float]" may be used.