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

Posted 2023-02-16

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

【英文标题】：How to access the carry flag while adding two 64 bit numbers using asm in C

【发布时间】：2017-10-12 04:21:05

【问题描述】：

是的，谢谢，它有效。 @彼得科德斯。 __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 也给了我错误，可能是因为我不确定语法。那么谁能告诉我如何将进位保存在另一个寄存器中或通过修改此代码返回它？

【问题讨论】：

你看过docs吗？

在较新版本的 GCC 上，您可以使用 "=@ccc"(carry) 输出约束来获取进位标志的值并将其存储到 carry 变量中。或者，您可以使用扩展汇编模板中的setc 指令将输出约束的值设置为进位标志的值。

或者您可以将asm goto 和jc 转换为return 1; 或直接转换为return 0; 如果您在if() 中使用它，这可以编译成好的代码。

顺便说一句，如果你的内联汇编中的第一条或最后一条指令是mov，你通常做错了。告诉编译器您希望在与输入之一相同的寄存器中产生输出，或者使用"+r" 读写操作数。见***.com/tags/inline-assembly/info。

@TanushreeBanerjee ：当您添加 "=@ccc"(carry) 约束时，您是否还通过调整参数来更改汇编器模板，因为它们不再是 %0、%1 和 %2。至少 %1 会变成 %2，而 %2 会变成 %3。如果您的某些参数通过插入新约束而偏离 1，我可以看到您在汇编器模板中出现错误。

【参考方案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 变量中，则不需要。

【讨论】：

@TanushreeBanerjee：你的意思是 32 位模式？对于 32 位代码中的 unsigned long long (uint64_t)，编译器已经非常优化地使用了 adc。编辑您的问题，具体说明您正在尝试加速编译器尚未最佳执行的操作。

我已经编辑了这个问题。所以现在你能建议我，应该修改什么，你认为它会加快实现速度吗？说当它完成100万次时，会有什么不同吗？

顺便说一句，我也尝试过 @MichaelPetch 所说的使用“=@c(carry)”，但是由于类型是定义的 uint64_t 这会产生负面的奇怪结果。当我将进位的数据类型更改为 int 时，它在 mov 指令中出现错误。我尝试了 movl、movw、movx，但没有任何效果。

是的 MichaelPetch 和 @Petercordes 那些工作。现在我也在考虑使用 Intel 的内部函数，但我不确定我是否在语法上做错了，你能告诉我吗？

@TanushreeBanerjee：我的回答已经链接了一个正确使用它们的问题。为什么不直接阅读我的答案；在我发布它之后，它已经回答了你在 cmets 中提出的所有问题。