# V117. Memsize type is used in the union.

The analyzer found a possible error related to the use of memsize inside a union. The error may occur while working with such unions without taking into account the size changes of memsize types on the 64-bit system.

One should be attentive to the unions which contain pointers and other members of memsize type.

The first example.

Sometimes one needs to work with a pointer as with an integer. The code in the example is convenient because the explicit type conversions are not used for work with the pointer number form.

    union PtrNumUnion {
      char *m_p;
      unsigned m_n;
    } u;
    ...
    u.m_p = str;
    u.m_n += delta;

This code is correct on 32-bit systems and is incorrect on 64-bit ones. Changing the 'm_n' member on the 64-bit system we work only with a part of the 'm_p' pointer. One should use that type which would conform with the pointer size as follows.

    union PtrNumUnion {
      char *m_p;
      size_t m_n; //type fixed
    } u;

The second example.

Another frequent case of use of a union is the representation of one member as a set of smaller ones. For example, we may need to split the 'size_t' type value into bytes for realization of the table algorithm of counting zero bits in a byte.

    union SizetToBytesUnion {
      size_t value;
      struct {
        unsigned char b0, b1, b2, b3;
      } bytes;
    } u;

    SizetToBytesUnion u;
    u.value = value;
    size_t zeroBitsN = TranslateTable[u.bytes.b0] +
                       TranslateTable[u.bytes.b1] +
                       TranslateTable[u.bytes.b2] +
                       TranslateTable[u.bytes.b3];

A fundamental algorithmic error is made here which is based on the supposition that the 'size_t' type consists of 4 bytes. The automatic search of algorithmic errors is not possible on the current stage of development of static analyzers but Viva64 provides search of all the unions which contain memsize types. Looking through the list of such potentially dangerous unions a user can find logical errors. On finding the union given in the example a user can detect an algorithmic error and rewrite the code in the following way.

    union SizetToBytesUnion {
      size_t value;
      unsigned char bytes[sizeof(value)];
    } u;

    SizetToBytesUnion u;
    u.value = value;
    size_t zeroBitsN = 0;
    for (size_t i = 0; i != sizeof(u.bytes); ++i)
      zeroBitsN += TranslateTable[u.bytes[i]];

This warning message is similar to the warning V122.

Additional materials on this topic:

- 64-bit Lessons. Lesson 16. Pattern 8. Memsize-types in unions.