This section explains the data type and the internal data representation. The internal data representation is determined according to the following four items:

Shows the memory size necessary to store the data.

Restricts the addresses to which data is allocated. There are three types of alignment; 1-byte alignment in which data can be allocated to any address, 2-byte alignment in which data is allocated to even byte addresses, and 4-byte alignment in which data is allocated to addresses of multiples of four bytes.

Shows the range of data of scalar type (C) or basic type (C++).

Shows an example of assignment of element data of compound type (C) or class type (C++).

Table 3.15 shows internal representation of scalar type data in C and basic type data in C++.

This section explains internal representation of array type, structure type, and union type data in C and class type data in C++.

Table 4.16 shows internal representation of compound type and class type data.

In the following examples, a rectangle ( ) indicates four bytes. The diagonal line ( ) represents an unused area for alignment. The address increments from right to left (the left side is located at a higher address).

When structure members are allocated, an unused area may be generated between structure members to align them to boundaries.

struct {

 char a;

 int b;

} obj

If a structure has 4-byte alignment and the last member ends at an 1-, 2-, or 3-byte address, the following three, two, or one byte is included in this structure.

struct {

 int a;

 char b;

} obj

When an union has 4-byte alignment and its maximum member size is not a multiple of four, the remaining bytes up to a multiple of four is included in this union.

union {

 int a;

 char b[7];

} o;

For classes having no base class or virtual functions, data members are allocated according to the allocation rules of structure data.

class A{

  char data1;

  int data2;

public:

  A();

  int getData1(){return data1;}

}obj;

If a class is derived from a base class of 1-byte alignment and the start member of the derived class is 1-byte data, data members are allocated without unused areas.

class A{

  char data1;

};

class B:public A{

  char data2;

  short data3;

}obj;

For a class having a virtual base class, a pointer to the virtual base class is allocated.

class A{

   short data1;

};

class B: virtual protected A{

   char data2;

}obj;

For a class having virtual functions, the compiler creates a virtual function table and allocates a pointer to the virtual function table.

class A{

    char data1;

  public:

    virtual int getData1();

}obj;

An example is shown for class having virtual base class, base class, and virtual functions.

class A{

  char data1;

  virtual short getData1();

};

class B:virtual public A{

  char data2;

  char getData2();

  short getData1();

};

class C:virtual protected A{

  int data3;

};

class D:virtual public A,public B,public C{

  public:

  int data4;

  short getData1();

}obj;

For an empty class, a 1-byte dummy area is assigned.

class A{

  void fun();

}obj;

For an empty class having an empty class as its base class, the dummy area is one byte.

class A{

  void fun();

};

class B: A{

  void sub();

}obj;

Dummy areas shown in the above two examples are allocated only when the class size is 0. No dummy area is allocated if a base class or a derived class has a data member or has a virtual function.

class A{

  void fun();

};

class B: A{

  char data1;

}obj;

A bit field is a member allocated with a specified size in a structure, a union, or a class. This section explains how bit fields are allocated.

Table 3.17 shows the specifications of bit field members.

Bit field members are allocated according to the following five rules:

struct b1 {

  int a:2;

  int b:3;

} x;

struct b1 {

  long           a:2;

  unsigned int   b:3;

} y;

struct b1 {

  int    a:5;

  char   b:4;

} z;

struct b2 {

  char   a:5;

  char   b:4;

} v;

struct b2 {

  char   a:5;

  char    :0;

  char   c:3;

} w;

In big endian, data are allocated in the memory as follows:

The order of bits in one-byte data for the little endian and the big endian is the same.

The upper byte and the lower byte will be reversed in two-byte data between the little endian and the big endian.

Little Endian: Address 0x100: 0x34 Big Endian: Address 0x100: 0x12
Address 0x101: 0x12 Address 0x101: 0x34

The order of bytes will be reversed in four-byte data between the little endian and the big endian.

Little Endian: Address 0x100: 0x78 Big Endian: Address 0x100: 0x12
Address 0x101: 0x56 Address 0x101: 0x34
Address 0x102: 0x34 Address 0x102: 0x56
Address 0x103: 0x12 Address 0x103: 0x78

The order of bytes will be reversed in eight-byte data between the little endian and the big endian.

Little Endian: Address 0x100: 0xef Big Endian: Address 0x100: 0x01
Address 0x101: 0xcd Address 0x101: 0x23
Address 0x102: 0xab Address 0x102: 0x45
Address 0x103: 0x89 Address 0x103: 0x67
Address 0x104: 0x67 Address 0x104: 0x89
Address 0x105: 0x45 Address 0x105: 0xab
Address 0x106: 0x23 Address 0x106: 0xcd
Address 0x107: 0x01 Address 0x107: 0xef

Members of compound-type and class-type data will be allocated in the same way as that of the little endian. However, the order of byte data of each member will be reversed according to the rule of data size.

struct {

	   short a;

	   int b;

	}z= {0x1234,  0x56789abc};

Little Endian: Address 0x100: 0x34 Big Endian: Address 0x100: 0x12
Address 0x101: 0x12 Address 0x101: 0x34
Address 0x102: Unused area Address 0x102: Unused area
Address 0x103: Unused area Address 0x103: Unused area
Address 0x104: 0xbc Address 0x104: 0x56
Address 0x105: 0x9a Address 0x105: 0x78
Address 0x106: 0x78 Address 0x106: 0x9a
Address 0x107: 0x56 Address 0x107: 0xbc

Bit fields will be allocated in the same way as that of the little endian. However, the order of byte data in each area will be reversed according to the rule of data size.

struct {

	   long a:16;

	   unsigned int b:15;

	   short c:5;

	}y= {1,1,1};

Little Endian: Address 0x100: 0x01 Big Endian: Address 0x100: 0x00
Address 0x101: 0x00 Address 0x101: 0x01
Address 0x102: 0x01 Address 0x102: 0x00
Address 0x103: 0x00 Address 0x103: 0x01
Address 0x104: 0x01 Address 0x104: 0x00
Address 0x105: 0x00 Address 0x105: 0x01
Address 0x106: Unused area Address 0x106: Unused area
Address 0x107: Unused area Address 0x107: Unused area

Floating-point numbers handled by this compiler are internally represented in the standard IEEE format. This section outlines the internal representation of floating-point numbers in the IEEE format.

This section assumes that the dbl_size=8 option is specified. When the dbl_size=4 option is specified, the internal representation of the double type and long double type is the same as that of the float type.

float types are represented in the IEEE single-precision (32-bit) format, while double types and long double types are represented in the IEEE double-precision (64-bit) format.

Figure 3.1 shows the structure of the internal representation of float, double, and long double types.

The internal representation format consists of the following parts:

i. Sign

Shows the sign of the floating-point number. 0 is positive, and 1 is negative.

ii. Exponent

Shows the exponent of the floating-point number as a power of 2.

iii. Mantissa

Shows the data corresponding to the significant digits (fraction) of the floating-point number.

In addition to the normal real numbers, floating-point numbers can also represent values such as infinity. The following describes the types of values represented by floating-point numbers.

i. Normalized number

Represents a normal real value; the exponent is not 0 or not all bits are 1.

ii. Denormalized number

Represents a real value having a small absolute number; the exponent is 0 and the mantissa is other than 0.

iii. Zero

Represents the value 0.0; the exponent and mantissa are 0.

iv. Infinity

Represents infinity; all bits of the exponent are 1 and the mantissa is 0.

v. Not-a-number

Represents the result of operation such as "0.0/0.0", "/", or "", which does not correspond to a number or infinity; all bits of the exponents are 1 and the mantissa is other than 0.

Table 3.18 shows the types of values represented as floating-point numbers.

When denormalize=off is specified, denormalized numbers are processed as 0.

When denormalize=on is specified, denormalized numbers are processed as denormalized numbers.

The float type is internally represented by a 1-bit sign, an 8-bit exponent, and a 23-bit mantissa.

i. Normalized numbers

The sign indicates the sign of the value, either 0 (positive) or 1 (negative). The exponent is between 1 and 254 (28 2). The actual exponent is gained by subtracting 127 from this value. The range is between 126 and 127. The mantissa is between 0 and 223 1. The actual mantissa is interpreted as the value of which 223rd bit is 1 and this bit is followed by the decimal point. Values of normalized numbers are as follows:

(1)sign 2exponent127 (1 + (mantissa) 223)

Sign:

Exponent: 10000000(2) 127 = 1, where (2) indicates binary

Mantissa: 1.11(2) = 1.75

Value: 1.75 21 = 3.5

ii. Denormalized numbers

The sign indicates the sign of the value, either 0 (positive) or 1 (negative). The exponent is 0 and the actual exponent is 126. The mantissa is between 1 and 2231, and the actual mantissa is interpreted as the value of which 223rd bit is 0 and this bit is followed by the decimal point. Values of denormalized numbers are as follows:

(1)sign 2126 ((mantissa) 223)

Sign: +

Exponent: 126

Mantissa: 0.11(2) = 0.75, where (2) indicates binary

Value: 0.75 2126

iii. Zero

The sign is 0 (positive) or 1 (negative), indicating +0.0 or 0.0, respectively. The exponent and mantissa are both 0.

+0.0 and 0.0 are both the value 0.0.

iv. Infinity

The sign is 0 (positive) or 1 (negative), indicating + or , respectively.

The exponent is 255 (281).

The mantissa is 0.

v. Not-a-number

The exponent is 255 (281).

The mantissa is a value other than 0.

The double and long double types are internally represented by a 1-bit sign, an 11-bit exponent, and a 52-bit mantissa.

i. Normalized numbers

The sign indicates the sign of the value, either 0 (positive) or 1 (negative). The exponent is between 1 and 2046 (2112). The actual exponent is gained by subtracting 1023 from this value. The range is between 1022 and 1023. The mantissa is between 0 and 2521. The actual mantissa is interpreted as the value of which 252nd bit is 1 and this bit is followed by the decimal point. Values of normalized numbers are as follows:

(1)sign 2exponent1023 (1+(mantissa) 252)

Sign: +

Exponent: 1111111111(2) 1023 = 0, where (2) indicates binary

Mantissa: 1.111(2) = 1.875

Value: 1.875 20 = 1.875

ii. Denormalized numbers

The sign indicates the sign of the value, either 0 (positive) or 1 (negative). The exponent is 0 and the actual exponent is 1022. The mantissa is between 1 and 2521, and the actual mantissa is interpreted as the value of which 252nd bit is 0 and this bit is followed by the decimal point. Values of denormalized numbers are as follows:

(1)sign 21022 ((mantissa) 252)

Sign:

Exponent: 1022

Mantissa: 0.111(2) = 0.875, where (2) indicates binary

Value: 0.875 21022

iii. Zero

The sign is 0 (positive) or 1 (negative), indicating +0.0 or 0.0, respectively. The exponent and mantissa are both 0.

+0.0 and 0.0 are both the value 0.0.

iv. Infinity

The sign is 0 (positive) or 1 (negative), indicating + or , respectively. The exponent is 2047 (2111).

The mantissa is 0.

v. Not-a-number

The exponent is 2047 (2111).

The mantissa is a value other than 0.