[CSAPP Practice Problem 2.32] tsub_ OK (int x, int y) judge whether complement subtraction overflows

 Practice Problem 2.32：

You are assigned the task of writing code for a function tsub_ok, with arguments x and y, that will return 1 if computing x-y does not cause overflow. Having just written the code for Problem 2.30, you write the following:

/* Determine whether arguments can be subtracted without overflow */
/* WARNING: This code is buggy. */
int tsub_ok(int x, int y)
{
    return tadd_ok(x, -y);
}

For what values of x and y will this function give incorrect results? Writing a correct version of this function is left as an exercise.

  First , Several concepts should be clarified ：

1. overflow ： Refer to The result of computer calculation And The result of simple arithmetic operation Different .（ The reason for this phenomenon is a certain type of digit （size） Not enough to accommodate the results , So it is called overflow .）
2. Subtraction of complement ： There is no subtraction unit inside the computer , So the subtraction operation is actually ：x-y=x+(-y), Still apply addition , It's just a reversal of the minus sign .
3. Complement negative ： When x When it is the minimum , Its negative value is still itself , In other cases, the result is -x.

So said , When y It's not equal to INT_MIN when , The result should be tadd_ok(x, -y); And when y Exactly equal to INT_MIN when , because -y The result is still INT_MIN, So we need to discuss again .

When y==INT_MIN when ：（ For the convenience of discussion , hypothesis int Only those who have 4bit size .）

1. if x It's a nonnegative number , for instance ：x=[0010]->2,y=[1000]->-8, Note that the result of computer calculation is a, The result of pure arithmetic operation is b. be -y=[1000]->-8,a=x-y=x+(-y)=[0010]+[1000]=[1010]->-6,b=x-y=10.a!=b, Therefore, overflow occurs .
2. if x It's a negative number , Take the same example ：x=[1111]->-1,y=[1000]->-8, Note that the result of computer calculation is a, The result of pure arithmetic operation is b. be -y=[1000]->-8,a=x-y=x+(-y)=[1111]+[1000]=[0111]->7,b=x-y=7.a==b, Therefore, there is no overflow .

in other words , Correct tsub_ok function , It should be written like this ：

int tsub_ok(int x, int y)
{
    if (y == INT_MIN) {
        if (x >= 0) {
            return 0;
        } else {
            return 1;
        }
    } else {
        return tadd_ok(x, -y);
    }
}

  Here is the official answer ：

 Solution to Problem 2.32

This function will give correct values, except when y is TMin. In this case, we will have -y also equal to TMin, and so the call to function tadd_ok will indicate overflow when x is negative and no overflow when x is nonnegative. In fact, the opposite is true: tsub_ok(x, TMin) should yield 0 when x is negative and 1 when it is nonnegative.

One lesson to be learned from this exercise is that TMin should be included as one of the cases in any test procedure for a function.

There seems to be something wrong with the italics , The Chinese translation I checked is ： When x When it's negative ,tsub_ok(x, TMin) Should be 1, When x When it is non negative ,tsub_ok(x, TMin) Should be 0. But the Chinese meaning of this sentence seems to be ： When x When it's negative ,tsub_ok(x, TMin) Should be 0, When x When it is non negative ,tsub_ok(x, TMin) Should be 1.

I don't know whether there is a problem with this sentence or my English level .