splitting a 64-bit addition into two 32-bit additions

I'm working on an ultra-performance-intensive computational task. For adding-pairwise two 32-bit integer arrays, could one, on a 64-bit architecture, treat two 32-bit values as a single 64-bit value, add them to their complement on the other array, then split them up again with a bitwise & operator. Obviously if there is an overflow, they will not be the same, but assuming there is none, will there b开发者_如何转开发e a problem? (And can you continue this to 16 and 8 bit additions?)

Does the behavior change for unsigned vs signed?

There's no difference between signed and unsigned - on two's complement machine it's just one instruction that doesn't know about the sign. Yes, you can safely do this trick if there's no overflow risk and you can do this for subparts of any lengths, for example, you can think that your 64-bit number holds two 13-bit numbers and one 38-bit number.

If you assume no overflow, you can do this down to single bits. Of course, 1+1 overflows. But in pratice, you either have overflow, or you really had 31 bit integers to start with.

One other thing: it only works on unsigned types. You can't have a sign bit in the middle of a 64 bit number.

But why do you care? If you're going "ultra-performance-intensive", use SSE. It will do parallel addition properly.

Yes, you can do this, but it would only work for unsigned values. With signed 32bit integers, the sign bit is the high order bit, which causes overflow when adding.

You probably don't need to do this - if your native C compiler isn't giving the performance you need, then look at using the vector operations (MMX, SSE etc) that do this sort of vector operations extremely efficiently.