C output changed by adding a printf

Question

int32_t result = registers[rs] + registers[rt];  
if (((registers[rs] > 0) && (registers[rt] > 0) && (result < 0)) || 
    ((registers[rs] < 0) && (registers[rt] < 0) && (result > 0))) {
        fprintf(stderr, "arithmetic overflow\n");
} else {
        registers[rd] = result;
}

Just a simple add and detect the overflow, if registers[rs] is 2147483647 and registers[rt] is 1, registers[rd] will have a result -2147483648. But if I add a printf("%d\\n", result) after declaring the variable result with same value in rs and rt, it will display arithmetic overflow

when registers[rs] is 2147483647 and registers[rt] is 1, it should output the arithmetic overflow

Answer 1

int32_t result = registers[rs] + registers[rt];  

When signed integer overflow occurs it invokes UB(Undefined Bahaviour).

You need to check before you add those integers.

bool willOverflow(int32_t a, int32_t b) 
{
    bool overflow = false;

    if (a > 0 && b > 0 && (a > INT32_MAX - b))  
    {
        overflow = true;
    }
    else if (a < 0 && b < 0 && (a < INT32_MIN - b)) 
    {
        overflow = true;
    }

    return overflow;
}

if (willOverflow(registers[rs], registers[rt]))
{
    fprintf(stderr, "arithmetic overflow\n");
} 
else 
{
    registers[rd] = registers[rs] + registers[rt];
}

Answer 2

If you have a potentially overflowing signed integer operation, you need to check if it overflows before performing the operation. Otherwise, if it overflows, your program will have undefined behavior and it could do or print just about anything.

In C23, ckd_add, ckd_sub and ckd_mul was added which checks for overflow before doing the addition, subtraction or multiplication:

#include <inttypes.h>
#include <stdckdint.h> // chd_add, ckd_sub, ckd_mul
#include <stdint.h>
#include <stdio.h>

void foo() {
    // ...

    int32_t result;
    if (ckd_add(&result, registers[rs], registers[rt])) {
        fputs("arithmetic overflow\n", stderr);
    } else {
        printf("All's well, the result is %" PRId32 "\n", result);
    }    
}

If you can't use C23, you could make your own function that checks before adding:

bool add_int32(int32_t *result, int32_t lhs, int32_t rhs) {
    // check if overflow would happen _before_ letting it happen:
    if ((rhs > 0 && INT32_MAX - rhs < lhs) ||
        (rhs < 0 && INT32_MIN - rhs > lhs))
    {
        return true; // overflow would happen
    } else {
        *result = lhs + rhs;
        return false;
    }
}

Note that the above hand-made function only handles int32_ts while the standard ckd_add is a macro using the _Generic operator to handle all integer types (other than plain char, bool and enumeration types) in any combination, as-if it was a function with the signature:

bool ckd_add(int_type1 *result, int_type2 x, int_type3 y);