Data Storage Formats

This section describes the storage formats of the data types available in the Cx51 compiler. The Cx51 compiler offers a number of basic data types to use in your C programs. The following table lists these data types along with their size requirements and value ranges.

Other data types, like structures and unions, may contain scalars from this table. All elements of these data types are allocated sequentially and are byte-aligned

Bit Variables

Scalars of type bit are stored using a single bit. Pointers to bits and arrays of bits are not allowed. Bit objects are always located in the bit-addressable internal memory of the 8051 CPU. The BL51 Linker/Locator overlays bit objects if possible.

Signed and Unsigned Characters,

Pointers to data, idata, and pdata

Scalars of type char are stored in a single byte (8 bits). Memory-specific pointers that reference data, idata, and pdata are also stored using a single byte (8 bits). If an enum can be represented with an 8 bit value, the enum is also stored in a single byte.

Signed and Unsigned Integers,

Enumerations, Pointers to xdata and code

Scalars of type int, short, and enum, and memory-specific pointers that reference xdata or code are all stored using two bytes (16 bits). The high-order byte is stored first, followed by the low-order byte. For example, an integer value of 0x1234 is stored in memory as follows:

Generic and Far Pointers

Generic pointers have no declared explicit memory type. They may point to any memory area on the 8051. These pointers are stored using three bytes (24 bits). The first byte contains a value that indicates the memory area or memory type.

The remaining two bytes contain the address offset with the high-order byte first. The following memory format is used:

Depending on the compiler version that you are using, the memory type byte has the following values:

The Philips 80C51MX architecture supports new CPU instructions that operate on a universal pointer. Universal pointers are identical with Cx51 generic pointers.

The format of the generic pointers is also used for pointers with the memory type far. Therefore, any other memory type values are used to address far memory space.

Floating-point Numbers

Scalars of type float are stored using four bytes (32-bits). The format used follows the IEEE-754 standard.

A floating-point number is expressed as the product of two parts: the mantissa and a power of two. For example:

±mantissa × 2exponent

The mantissa represents the actual binary digits of the floating-point number.

The power of two is represented by the exponent. The stored form of the exponent is an 8-bit value from 0 to 255. The actual value of the exponent is calculated by subtracting 127 from the stored value (0 to 255) giving a range of – 127 to +128.

The mantissa is a 24-bit value (representing about seven decimal digits) whose most significant bit (MSB) is always 1 and is, therefore, not stored. There is also a sign bit that indicates whether the floating-point number is positive or negative.

Floating-point numbers are stored on byte boundaries in the following format:

Zero is a special value denoted with an exponent field of 0 and a mantissa of 0.

180 Chapter 6. Advanced Programming Techniques

The floating-point number -12.5 is stored as a hexadecimal value of 0xC1480000. In memory, this value appears as follows:

It is fairly simple to convert floating-point numbers to and from their hexadecimal storage equivalents. The following example demonstrates how this is done for the value -12.5 shown above.

The floating-point storage representation is not an intuitive format. To convert this to a floating-point number, the bits must be separated as specified in the floating-point number storage format table shown above. For example:

From this illustration, you can determine the following information:

The sign bit is 1, indicating a negative number.

The exponent value is 10000010 binary or 130 decimal. Subtracting 127 from 130 leaves 3, which is the actual exponent.

There is an understood binary point at the left of the mantissa that is always preceded by a 1. This digit is omitted from the stored form of the floating-point number. Adding 1 and the binary point to the beginning of the mantissa gives the following value:

1.10010000000000000000000

Next, adjust the mantissa for the exponent. A negative exponent moves the decimal point to the left. A positive exponent moves the decimal point to the right. Because the exponent is three, the mantissa is adjusted as follows:

1100.10000000000000000000

The result is a binary floating-point number. Binary digits to the left of the decimal point represent the power of two corresponding to their position. For example, 1100 represents (1 × 23) + (1 × 22) + (0 × 21) + (0 × 20), which is 12.

Binary digits to the right of the decimal point also represent the power of two

corresponding to their position. However, the powers are negative. For example, .100… represents (1 × 2-1) + (0 × 2-2) + (0 × 2-3) + … which equals

.5.

The sum of these values is 12.5. Because the sign bit was set, this number should be negative. So, the hexadecimal value 0xC1480000 is -12.5.

6

Floating-point Errors

The 8051 does not contain an interrupt vector to trap floating-point errors; therefore, your software must appropriately respond to these error conditions.

In addition to the normal floating-point values, a floating-point number may contain a binary error value. These values are defined as a part of the IEEE standard and are used whenever an error occurs during normal processing of floating-point operations. Your code should check for possible arithmetic errors at the end of each floating-point operation.

NOTE

The Cx51 library function _chkfloat_ lets you quickly check floating-point status.

You can use the following union to store floating-point values.

For example:

x.f = a * b;

if (x.ul == NaN || x.ul == plusINF || x.ul == minusINF) { /* handle the error */

}

else {

/* result is correct */

}

}

6