Unexpected warning

Today I refactored a function in my C program in order to make it more readable and remove special-casing. What came unexpected is that I got a new warning in a function that I didn't touch. While this sounds strange, here is a very simple example that shows how it could happen.

This is the function that I didn't touch, but that will, at the end, get a warning:

extern const int db_to_add[32];

static int add_db(int a, int b)
{
 if (a < b) {
  int tmp = a;
  a = b;
  b = tmp;
 }
 if (a - b >= 32)
  return a;

 return a + db_to_add[a - b];
}

Here is a caller, just to make it sure that a static function is used:

int peak_db[32];
static int noise(int band1, int band2, int spectrum1, int spectrum2)
{
 /* actually a lot more complex, but the idea is that
    it takes two bands, except for special cases */
 int noise1 = peak_db[band1] + spectrum1;
 int noise2 = peak_db[band2] + spectrum2;
 return add_db(noise1, noise2);
}

int valid_use(int b, int s)
{
 /* a dummy warning-free function
    only for the purpose of this blog post */
 return noise(b, b + 1, 0, s);
}

With all of the above, there is no warning, even when "-O3 -Wall" flags are passed to gcc. Now add this (in the real program, this is the result of value propagation over various branches):

int trigger_warning()
{
 return noise(0, 0, 0, -200);
}

The intention is to attenuate the unneeded term enough so that it doesn't matter, and use the general two-band case. With gcc-4.3.1 -O3 -Wall, the result, referring to the line in add_db() where a is compared with b, is:

warning: assuming signed overflow does not occur when assuming that (X - c) > X is always false

So it looks like gcc inlined everything and attempted to test whether peak_db[0] < peak_db[0] - 200. Because C compilers are allowed to think that signed overflow never occurs, this is always false (as intended). However, tests of this form are often incorrectly used as security checks, that's why the warning.