如何在 C 中使用 asm 添加两个 64 位数字时访问进位标志

Question

是的，谢谢，它有效。 @彼得科德斯。 __int128 也有效。但是，正如您所说的另一件事，使用 C 中 _addcarry_u64 的多精度算术的内在函数，使用头文件 immintrin.h 我有以下代码

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <immintrin.h>

unsigned char _addcarry_u64(unsigned char c_in, uint64_t src1, uint64_t src2,uint64_t *sum);

int main()
{
    unsigned char carry;
    uint64_t sum;
    long long int c1=0,c2=0;
    uint64_t a=0x0234BDFA12CD4379,b=0xA8DB4567ACE92B38;
    carry = _addcarry_u64(0,a,b,&sum);
    printf("sum is %lx and carry value is %u n",sum,carry);
    return 0;
}

你能指出错误吗？我收到了对_addcarry_u64 的未定义引用。一些快速的谷歌没有回答问题，如果要使用任何其他头文件或者它与 gcc 不兼容，为什么会这样

最初我有这段代码用于添加两个 64 位数字：

static __inline int is_digit_lessthan_ct(digit_t x, digit_t y)
{ // Is x < y?
    return ( int)((x ^ ((x ^ y) | ((x - y) ^ y))) >> (RADIX-1)); 
}


#define ADDC(carryIn, addend1, addend2, carryOut, sumOut) \
       { digit_t tempReg = (addend1) + (int)(carryIn);    \
                (sumOut) = (addend2) + tempReg;           \
              (carryOut) = (is_digit_lessthan_ct(tempReg, (int)(carryIn)) | is_digit_lessthan_ct((sumOut), tempReg)); \
 }

现在我知道使用汇编语言可以提高此实现的速度。因此，我正在尝试做类似的事情，但是我无法访问或归还进位。这是我的代码：

#include<stdio.h>
#include<stdlib.h>
#include<stdint.h>
uint64_t add32(uint64_t a,uint64_t b)
{
    uint64_t d=0,carry=0;
    __asm__("mov %1,%%rax\n\t"
            "adc %2,%%rax\n\t"
            "mov %%rax,%0\n\t"
            :"=r"(d)
            :"r"(a),"r"(b)
            :"%rax"
           );
    return d;
}
int main()
{
    uint64_t a=0xA234BDFA12CD4379,b=0xA8DB4567ACE92B38;
    printf("Sum = %lx \n",add32(a,b));
    return 0;
}

此加法的结果应该是 14B100361BFB66EB1，其中 msb 中的初始 1 是进位。我想将该进位保存在另一个寄存器中。我尝试了 jc，但我遇到了一些或其他错误。甚至 setc 也给了我错误，可能是因为我不确定语法。那么谁能告诉我如何将进位保存在另一个寄存器中或通过修改此代码返回它？

Answer 1

像往常一样，内联汇编并不是绝对必要的。 https://gcc.gnu.org/wiki/DontUseInlineAsm。但是目前编译器对于实际的扩展精度加法有点糟糕，所以你可能需要 asm。

adc 有一个 Intel 内在函数：_addcarry_u64。但不幸的是gcc and clang may make slow code.。在 64 位平台上的 GNU C 中，您可以只使用 unsigned __int128。

---

编译器在检查加法的进位时通常会设法编写非常好的代码使用carry_out = (x+y) < x的习语，其中<是一个无符号比较。例如：

struct long_carry { unsigned long res; unsigned carry; };

struct long_carry add_carryout(unsigned long x, unsigned long y) {
    unsigned long retval = x + y;
    unsigned carry = (retval < x);
    return (struct long_carry){ retval, carry };
}

gcc7.2 -O3 emits this（和 clang 发出类似的代码）：

    mov     rax, rdi        # because we need return value in a different register
    xor     edx, edx        # set up for setc
    add     rax, rsi        # generate carry
    setc    dl              # save carry.
    ret                     # return with rax=sum, edx=carry  (SysV ABI struct packing)

使用 inline asm 没有比这更好的方法了；这个函数看起来对于现代 CPU 来说已经是最优的了。 （好吧，我猜如果mov 不是零延迟，那么首先执行add 会缩短携带准备就绪的延迟。但是在英特尔CPU 上，最好立即覆盖mov-elimination 结果，所以它是最好先移动，然后添加。）

---

Clang 甚至会使用 adc 将 add 的进位用作另一个 add 的进位，但仅限于第一个分支。可能是因为：更新：this function is broken：carry_out = (x+y) < x 在带入时不起作用。使用carry_out = (x+y+c_in) < x，y+c_in 可以归零并给你(x+0) < x (false)，即使有进位。

请注意，clang 的 cmp/adc reg,0 完全实现了 C 的行为，这与那里的另一个 adc 不同。

无论如何，gcc 在第一次使用adc 时，它是安全的。 （所以对于不糟糕的代码使用unsigned __int128，对于比这更宽的整数使用 asm）。

// BROKEN with carry_in=1 and y=~0U
static
unsigned adc_buggy(unsigned long *sum, unsigned long x, unsigned long y, unsigned carry_in) {
    *sum = x + y + carry_in;
    unsigned carry = (*sum < x);
    return carry;
}

// *x += *y
void add256(unsigned long *x, unsigned long *y) {
    unsigned carry;
    carry = adc(x, x[0], y[0], 0);
    carry = adc(x+1, x[1], y[1], carry);
    carry = adc(x+2, x[2], y[2], carry);
    carry = adc(x+3, x[3], y[3], carry);
}

    mov     rax, qword ptr [rsi]
    add     rax, qword ptr [rdi]
    mov     qword ptr [rdi], rax

    mov     rax, qword ptr [rdi + 8]
    mov     r8, qword ptr [rdi + 16]   # hoisted
    mov     rdx, qword ptr [rsi + 8]
    adc     rdx, rax                   # ok, no memory operand but still adc
    mov     qword ptr [rdi + 8], rdx

    mov     rcx, qword ptr [rsi + 16]   # r8 was loaded earlier
    add     rcx, r8
    cmp     rdx, rax                    # manually check the previous result for carry.  /facepalm
    adc     rcx, 0

    ...

这很糟糕，所以如果你想要扩展精度加法，你仍然需要 asm。但是要将结转输出到 C 变量中，则不需要。