Updated: as promised, my solution in Part 3.
Continued from Part 1 - following some discussion in the comments
Michael Herf and Eric O'Laughlen suggested I try a bit of x86 assembly to salve my problem (a good suggestion - at least to establish a performance baseline; I still ultimately want C), but I must be doing something wrong...
Here were my time tests:
-------------------- Math requiring no overflow detection
-------------------- This is for speed (overhead)
Testing Simple..... total: 750201700 Time = 484.331 ms
Testing ASM Safe... total: 750201700 Time = 1370.02 ms
Testing MS Safe.... total: 750201700 Time = 872.027 ms
Testing Sree Safe.. total: 750201700 Time = 523.12 ms
-------------------- Math requiring overflow detection
-------------------- This is for correctness - ignore timings for 'Simple'
Testing Simple..... total: -120255288 Time = 482.925 ms*
Testing ASM Safe... total: 2147483518 Time = 222.645 ms EXCEPTION
Testing MS Safe.... total: 2147483518 Time = 141.048 ms EXCEPTION
Testing Sree Safe.. total: 2147483518 Time = 101.048 ms EXCEPTION
Simple is just "a+b" whereas ASM is the code others suggested, and MS is from Microsoft's MSDN article on the subject. I fully expected the ASM one to be faster than the MS case - so its gotta be me (or that just is the fastest/cleanest way?). I think the conditional is killing it. My C case is I think as good as it gets, and a nice replacement for Microsoft's, but I should verify validity before I go shooting my mouth...
(*btw, Simple is there just for reference for perf and correctness. In particular, since it DOESN'T throw an exception in the bottom tests, it is "slower" because it COMPLETES the test - the other two do not; they throw an exception part way through, as noted by "EXCEPTION".)
You can grab the benchmark executable or the source, and try it for yourself.
I had added both of their suggestions (Mike's and Eric's), but neither passed the correctness test. They didn't toss exceptions in the right cases, or (in Eric's case) were much slower than MS and ASM both once I added an exception-toss-on-overflow-flag-set test - though both were faster so long as you didn't want to actually look at the overflow result immediately, which unfortunately, I think you usually do.
As Herf points out - I think the branch prediction kills the assembly attempts.
I have a (probably too) simple idea in just C, but want to validate it (perf and correctness) before I post - hopefully I'll get a chance to do something this week. This so seemed like an already well solved problem to me?