gcc 内联汇编中与 PC 相关的跳转

Question

我有一个 asm 循环，保证不会超过 128 次迭代，我想用 PC 相对跳转来展开它。这个想法是以相反的顺序展开每个迭代，然后跳到需要的循环中。代码看起来像这样：

#define __mul(i) \
    "movq -"#i"(%3,%5,8),%%rax;" \
    "mulq "#i"(%4,%6,8);" \
    "addq %%rax,%0;" \
    "adcq %%rdx,%1;" \
    "adcq $0,%2;"

asm("jmp (128-count)*size_of_one_iteration" // I need to figure this jump out
    __mul(127)
    __mul(126)
    __mul(125)
    ...
    __mul(1)
    __mul(0)
    : "+r"(lo),"+r"(hi),"+r"(overflow)
    : "r"(a.data),"r"(b.data),"r"(i-k),"r"(k)
    : "%rax","%rdx");

Is like this possible with gcc inline assembly?

Answer 1

在 gcc 内联汇编中，您可以使用标签并让汇编器为您整理跳转目标。就像（人为的例子）：

int max(int a, int b)
{
    int result;
    __asm__ __volatile__(
        "movl %1, %0\n"
        "cmpl %2, %0\n"
        "jeq  a_is_larger\n"
        "movl %2, %0\n"
        "a_is_larger:\n" : "=r"(result), "r"(a), "r"(b));
    return (result);
}

那是一回事。为了避免乘法，您可以做的另一件事是让汇编器为您对齐块，例如，以 32 字节的倍数对齐（我认为指令序列不适合 16 字节），就像：

#define mul(i)                     \
    ".align 32\n"                  \
    ".Lmul" #i ":\n"               \
    "movq -" #i "(%3,%5,8),%%rax\n"\
    "mulq " #i "(%4,%6,8)\n"       \
    "addq %%rax,%0\n"              \
    "adcq %%rdx,%1\n"              \
    "adcq $0,%2\n"

这将简单地用 nop 填充指令流。如果您选择不对齐这些块，您仍然可以在主表达式中使用生成的本地标签来查找汇编块的大小：

#ifdef UNALIGNED
__asm__ ("imul $(.Lmul0-.Lmul1), %[label]\n"
#else
__asm__ ("shlq $5, %[label]\n"
#endif
    "leaq .Lmulblkstart, %[dummy]\n"        /* this is PC-relative in 64bit */
    "jmp (%[dummy], %[label])\n"
    ".align 32\n"
    ".Lmulblkstart:\n"
    __mul(127)
    ...
    __mul(0)
    : ... [dummy]"=r"(dummy) : [label]"r"((128-count)))

对于 count 是编译的情况时间常数，您甚至可以这样做：

__asm__("jmp .Lmul" #count "\n" ...);

最后的小注释：

如果自动生成的 _mul() 东西可以创建不同长度的序列，则对齐块是一个好主意。对于您使用的常量 0..127 ，情况并非如此，因为它们都适合一个字节，但如果您将它们放大，它将变为 16 位或 32 位值和指令块将随之增长。通过填充指令流，仍然可以使用跳转表技术。

Answer 2

这不是直接答案，但您是否考虑过使用变体
Duff 的设备而不是内联
集会？这将采用 switch 语句的形式：

switch(iterations) {
  case 128: /* code for i=128 here */
  case 127: /* code for i=127 here */
  case 126: /* code for i=126 here */
  /* ... */
  case 1:   /* code for i=1 here*/
  break;
  default: die("too many cases");
}

Answer 3

抱歉，我无法提供 ATT 语法的答案，希望您能轻松执行翻译。

如果您在 RCX 中有计数，并且可以在 __mul(0) 之后有一个标签，那么您可以这样做：

; rcx must be in [0..128] range.
    imul ecx, ecx, -size_of_one_iteration ; Notice the multiplier is negative (using ecx is faster, the upper half of RCX will be automatically cleared by CPU)
    lea  rcx, [rcx + the_label] ; There is no memory read here
    jmp  rcx

希望这会有所帮助。

编辑：
我昨天犯了一个错误。我假设引用 [rcx + the_label] 中的标签被解析为 [rcx + rip + disp] 但事实并非如此，因为没有这样的寻址模式（仅存在 [rip + disp32]）

此代码应该可以工作，另外它将使 rcx 保持不变，并会销毁 rax 和 rdx （但您的代码似乎在先写入它们之前不会读取它们）：

; rcx must be in [0..128] range.
    imul edx, ecx, -size_of_one_iteration ; Notice the multiplier is negative (using ecx is faster, the upper half of RCX will be automatically cleared by CPU)
    lea  rax, [the_label] ; PC-relative addressing (There is no memory read here)
    add  rax, rdx
    jmp  rax