Agner`s CPU blog

1. Put the two big numbers into vector registers A and B, or as much of the numbers that will fit into the maximum vector length
2. Calculate the sums of all 64-bit vector elements: C = A + B
3. Make a vector of the carries, one bit in each 64-bit element: D = (C < A)
4. Find elements with all ones: E = (C == -1)
5. Combine bit 0 of each element of C into an integer bitfield: D1 = convert_boolean_vector_to_bitfield(D)
6. Do the same with E: E1 = convert_boolean_vector_to_bitfield(E)
7. Use integer operations to do the carry look-ahead. D1 is the elements that generate carry, E1 is the elements that propagate carry. F = E1 xor (E1 + 2D1 + carry_in)
8. Convert back from bitfield to vector: F1 = convert_bitfield_to_boolean_vector(F)
9. Add the propagated carries: Sum = C + F1
10. Carry out if more rounds needed: Carry_out = F >> number_of_vector_elements

If we don't need extra carry bits for high precision arithmetics, then the only need for these extra bits is for detecting and propagating integer overflow.

If we don't have the extra carry flags, then we will need special instructions for checking if an addition, multiplication, etc. overflows. After each addition or other arithmetic instruction, issue another instruction with the same inputs just to check if the operation overflows. The outputs of all the overflow checks for a series of calculations should then be OR'ed together. The total number of instructions will be three times the number of instructions needed without overflow check.

So what are the costs and benefits? Without the extra flag bits we need three times as many instructions if we want to check for integer overflow. We can avoid overflow in many cases by using 64-bit integers, but even 64-bit integers can easily overflow if the calculation has many multiplications. Compiler support for checking integer overflow is rare, unfortunately, so any mechanism for detecting integer overflow will perhaps not be used much. On the other hand, if an efficient method was available, we would probably see compilers that support it and programmers that use it. In fact, many programmers are frustrated over how difficult it is to detect signed integer overflow. Traps for integer overflow exception is not good for vector code. One solution is to use floating point calculations instead of integer, but I don't see that solution used much. Floating point calculations have longer latencies, of course. No solution seems to be really good here.