The document discusses the potential issues when porting 32-bit programs to 64-bit systems, specifically regarding overloaded functions and type size differences. It highlights the risks involved with mixed-type usage in a stack class, where a careless programmer may face errors due to differing data sizes. The developers note that their diagnostic tool does not currently recognize this specific issue and encourage users to report any encountered errors.

1. Lesson 22. Pattern 14. Overloaded
functions
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);

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.
Diagnosis
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.
The course authors: Andrey Karpov (karpov@viva64.com), Evgeniy Ryzhkov (evg@viva64.com).
The rightholder of the course "Lessons on development of 64-bit C/C++ applications" is OOO "Program
Verification Systems". The company develops software in the sphere of source program code analysis.
The company's site: http://www.viva64.com.
Contacts: e-mail: support@viva64.com, Tula, 300027, PO box 1800.