Question

是的，谢谢你的作品。 @PeterCordes。 __int128也有效。但是，正如你所说的那样使用头文件_addcarry_u64中使用C 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

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

adc：_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)

使用内联asm，你无法做到比这更好;这个功能对于现代CPU来说已经是最佳选择。（我想如果mov不是零延迟，那么首先执行add会缩短进行准备的延迟。但是在Intel CPU上，应该更好地覆盖mov-elimination结果离开，所以最好先移动然后添加。）

Clang甚至会使用adc来使用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变量，你不需要。

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

1 个答案: