When porting a 32-bit program to a 64-bit platform, you may encounter changes in its logic related to the use of overloaded functions. If a function is overlapped for 32-bit and 64-bit values, the access to it with an argument of a memsize-type will be translated into different calls on different systems. This technique may be useful as, for example, in this code:
static size_t GetBitCount(const unsigned __int32 &) { return 32; } static size_t GetBitCount(const unsigned __int64 &) { return 64; } size_t a; size_t bitCount = GetBitCount(a);
But this change of logic is potentially dangerous. Imagine a program that uses a class to arrange the stack. This class is specific in that way that it allows you to store values of different types:
class MyStack { ... public: void Push(__int32 &); void Push(__int64 &); void Pop(__int32 &); void Pop(__int64 &); } stack; ptrdiff_t value_1; stack.Push(value_1); ... int value_2; stack.Pop(value_2);
A careless programmer saves into and then selects from the stack values of different types (“ptrdiff_t” and “int”). Their sizes coincide on the 32-bit system and everything is quite okay. But when the size of the type “ptrdiff_t” changes on the 64-bit system, the number of bytes saved into the stack gets larger than the number of bytes loaded then from the stack.
I think this type of errors is clear to you and you understand that one should be very careful about calls to overloaded functions when passing actual arguments of a memsize-type.
Diagnostic
PVS-Studio does not diagnose this pattern of 64-bit errors. First, it is explained by the fact that we have not encountered such an error in a real application yet, and second, diagnosis of such constructs involves some difficulties. Please write to us if you encounter such an error in real code.