Question

我正在做一个循环来对两个数组求和。我的目标是避免携带支票c = a + b; carry = (c<a)。当我使用CF指令进行循环测试时，我丢失了cmp。

目前，我正在使用JE和STC来测试和设置之前保存的CF状态。但跳跃需要更多的7个周期，这对我想要的东西来说很重要。

   //This one is working
   asm(
        "cmp $0,%0;"
        "je 0f;"
        "stc;"
    "0:"   
        "adcq %2, %1;"
        "setc %0"

    : "+r" (carry), "+r" (anum)
    : "r" (bnum)
   );

我已经尝试过使用SAHF（2 + 2（mov）周期），但这不起作用。

   //Do not works
   asm(
        "mov %0, %%ah;"
        "sahf;"
        "adcq %2, %1;"
        "setc %0"

        : "+r" (carry), "+r" (anum)
        : "r" (bnum)
   );

任何人都知道如何更快地设置CF？像直接移动或类似的东西..

Answer 1

Looping without clobbering CF will be faster。请参阅该链接以获得更好的asm循环。

不要试图在C循环中只使用内联asm编写adc。它不可能是最佳的，因为你不能要求gcc不要破坏旗帜。尝试用GNU C inline asm学习asm比编写独立函数更难，尤其是。在这种情况下，你试图保留进位标志。

您可以使用setnc %[carry]保存并subb $1, %[carry]进行恢复。（或者cmpb $1, %[carry]我猜。或者正如斯蒂芬指出的那样，negb %[carry]。

0 - 1生成一个进位，但1 - 1没有。

使用uint8_t变量来保存进位，因为您永远不会将其直接添加到%[anum]。这避免了partial-register slowdowns的任何可能性。 e.g。

uint8_t carry = 0;
int64_t numa, numb;

for (...) {
    asm ( "negb   %[carry]\n\t"
          "adc    %[bnum], %[anum]\n\t"
          "setc   %[carry]\n\t"
          : [carry] "+&r" (carry), [anum] "+r" (anum)
          : [bnum] "rme" (bnum)
          : // no clobbers
        );
}

您还可以为寄存器源reg / mem dest提供备用约束模式。我使用了an x86 "e" constraint而不是"i"，因为64位模式仍然只允许32位符号扩展的立即数。 gcc必须自己将更大的编译时常量放入寄存器中。 Carry是早期破坏的，所以即使它和bnum都是1开始，gcc也不能对两个输入使用相同的寄存器。

这仍然很糟糕，并且将循环携带的依赖链的长度从2c增加到4c（Intel pre-Broadwell），或从1c增加到3c（Intel BDW / Skylake和AMD）。

所以你的循环以1/3的速度运行，因为你使用的是kludge而不是在asm中编写整个循环。

此答案的先前版本建议直接添加进位，而不是将其恢复为CF。这种方法有一个致命的缺陷：它将传入的进位混合到这个迭代中，传出进位进入下一次迭代。

此外，sahf是来自Flags的Set AH。 lahf是将AH加载到Flags中（它在整个低8位的标志上运行。配对这些指令;不要在lahf的0或1上使用setc

阅读insn set参考手册，了解任何似乎没有达到预期效果的insn。见https://stackoverflow.com/tags/x86/info

Answer 2

如果在编译时已知数组大小，则可以执行以下操作：

#include <inttypes.h>
#include <malloc.h>
#include <stdio.h>
#include <memory.h>

#define str(s) #s
#define xstr(s) str(s)

#define ARRAYSIZE 4

asm(".macro AddArray2 p1, p2, from, to\n\t"
    "movq (\\from*8)(\\p2), %rax\n\t"
    "adcq %rax, (\\from*8)(\\p1)\n\t"
    ".if \\to-\\from\n\t"
    "   AddArray2 \\p1, \\p2, \"(\\from+1)\", \\to\n\t"
    ".endif\n\t"
    ".endm\n");

asm(".macro AddArray p1, p2, p3\n\t"
    "movq (\\p2), %rax\n\t"
    "addq %rax, (\\p1)\n\t"
    ".if \\p3-1\n\t"
    "   AddArray2 \\p1, \\p2, 1, (\\p3-1)\n\t"
    ".endif\n\t"
    ".endm");

int main()
{
   unsigned char carry;

   // assert(ARRAYSIZE > 0);

   // Create the arrays
   uint64_t *anum = (uint64_t *)malloc(ARRAYSIZE * sizeof(uint64_t));
   uint64_t *bnum = (uint64_t *)malloc(ARRAYSIZE * sizeof(uint64_t));

   // Put some data in
   memset(anum, 0xff, ARRAYSIZE * sizeof(uint64_t));
   memset(bnum, 0, ARRAYSIZE * sizeof(uint64_t));
   bnum[0] = 1;

   // Print the arrays before the add
   printf("anum: ");
   for (int x=0; x < ARRAYSIZE; x++)
   {
      printf("%I64x ", anum[x]);
   }
   printf("\nbnum: ");
   for (int x=0; x < ARRAYSIZE; x++)
   {
      printf("%I64x ", bnum[x]);
   }
   printf("\n");

   // Add the arrays
   asm ("AddArray %[anum], %[bnum], " xstr(ARRAYSIZE) "\n\t"
        "setc %[carry]" // Get the flags from the final add

       : [carry] "=q"(carry)
       : [anum] "r" (anum), [bnum] "r" (bnum)
       : "rax", "cc", "memory"
   );

   // Print the result
   printf("Result: ");
   for (int x=0; x < ARRAYSIZE; x++)
   {
      printf("%I64x ", anum[x]);
   }
   printf(": %d\n", carry);
}

这给出了这样的代码：

mov    (%rsi),%rax
add    %rax,(%rbx)
mov    0x8(%rsi),%rax
adc    %rax,0x8(%rbx)
mov    0x10(%rsi),%rax
adc    %rax,0x10(%rbx)
mov    0x18(%rsi),%rax
adc    %rax,0x18(%rbx)
setb   %bpl

由于向所有f添加1将完全溢出所有内容，因此上述代码的输出为：

anum: ffffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffff
bnum: 1 0 0 0
Result: 0 0 0 0 : 1

如上所述，ARRAYSIZE最多可达100个元素（由于gnu的宏深度嵌套限制）。好像它应该足够......

设置进位标志的最快方法

2 个答案: