Adventures with chatGPT

Recently I came across a surprising result with a short C++ code and asked GPT4 for guidance, it performed well:

Me: On visual studio 2022, when building in debug x86, why is the variable "a" printed as strange values like 4294967296 in the following c++ code: 

#include <stdio.h>

int main() {

    for (unsigned long long i = 0; i < 5; i++) {

        unsigned long long a = i;

        printf("i = %u, a = %llu\n", i, a);

    }

    getchar();

    return 0;

}

GPT4: The issue with the code you provided is the incorrect format specifier used in the printf() function for the variable i. Since i is of type unsigned long long, you should use %llu for it, not %u. The correct printf() statement should look like this:

printf("i = %llu, a = %llu\n", i, a);

Here's the corrected code:

#include <stdio.h>

int main() {

    for (unsigned long long i = 0; i < 5; i++) {

        unsigned long long a = i;

        printf("i = %llu, a = %llu\n", i, a);

    }

    getchar();

    return 0;

}

With this change, the code should now print the expected values for both i and a.

Me: Why does the the incorrect format specifier cause this?

GPT4: When you use an incorrect format specifier, the printf() function reads the wrong number of bytes from the argument list. This can cause undefined behavior, leading to incorrect output or even program crashes.

In your code, the incorrect format specifier %u is used for the unsigned long long variable i. %u is meant for unsigned int values, which are typically 4 bytes in size (on most platforms). However, unsigned long long values are typically 8 bytes in size. This means that the printf() function reads only half of the bytes it should for i, and the remaining bytes are incorrectly interpreted as part of the a value.

When printf() reads the argument list, it starts reading the next argument (in this case, a) from the incorrect position, causing the output to be garbled or contain strange values. The behavior is undefined because the C++ standard does not dictate what should happen when the wrong format specifier is used. The actual outcome depends on the specific implementation of the C++ library and the underlying hardware.

To avoid this problem, always ensure that the format specifiers in the printf() function match the types of the variables being printed.

Me: Why does this problem not happen when run in x64?

GPT4: The behavior you observed is specific to the x86 architecture because of the way it passes arguments to functions. In the x86 calling convention, function arguments are pushed onto the stack, and the stack is then used to pass values to the called function. This means that if the wrong format specifier is used, the mismatch in bytes read can cause incorrect values to be read from the stack.

However, in x64, the calling convention is different. On x64 platforms, function arguments are typically passed using registers instead of the stack. The first few arguments are passed in registers, and the rest are passed on the stack if needed. This means that, even if the wrong format specifier is used, the values in the registers are still correctly interpreted by the printf() function.

In your specific case, the i variable would be passed in a register, and the incorrect format specifier %u would cause printf() to read only the lower 4 bytes of the 8-byte register. Since the value of i is small and fits within 4 bytes, the output appears correct for the x64 build.

It's important to note that using the wrong format specifier is still undefined behavior and can lead to other issues. This example just happened to work on x64 due to the specific calling convention and the size of the variables involved. Always use the correct format specifier to ensure consistent behavior across platforms and avoid potential issues.