使用内联汇编时出现分段错误（核心转储）错误

我在 GCC 中使用内联汇编。我想将变量内容向左旋转 2 位（我将变量移动到 rax 寄存器，然后将其旋转 2 次）。我编写了下面的代码，但遇到了分段错误（核心转储）错误。 如果您能帮助我，我将不胜感激。

uint64_t X = 13835058055282163712U;
 asm volatile(
            "movq %0 , %%rax\n"
            "rol %%rax\n"
            "rol %%rax\n"
            :"=r"(X)
            :"r"(X)
         );
printf("%" PRIu64 "\n" , X);

理解内联 asm 的关键是理解每个 asm 语句都有两部分：

1. 实际汇编器内容的文本，编译器将在其中进行文本替换，但是不明白.

   这是汇编模板在文档中（直到第一个的所有内容: in the __asm__()).

2. 汇编器的作用的描述，就编译器而言确实明白.

   这就是: OutputOperands : InputOperands : Clobbers in 文档 https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html.

   这必须告诉编译器汇编器如何适应编译器围绕它生成的所有代码。代码生成忙于分配寄存器来保存值、决定执行操作的顺序、将操作移出循环、消除未使用的代码片段、丢弃不再需要的值等等。

   实际的汇编器是一个黑匣子，它接受此处描述的输入，产生所描述的输出，并且副作用可能会“破坏”一些寄存器和/或内存。这must是汇编器功能的完整描述...否则编译器在模板周围生成的汇编语言将与其发生冲突并依赖于错误的假设。

   有了这些信息compiler可以决定汇编器可以使用哪些寄存器，并且您应该让它这样做。

所以，你的片段：

 asm volatile(
            "movq %0 , %%rax\n"
            "rol %%rax\n"
            "rol %%rax\n"
            :"=r"(X)
            :"r"(X)
         );

有几个“问题”：

• 你可能已经选择了%rax基于 asm() 就像一个函数，并且可能期望返回结果%rax——但事实并非如此。
• 你继续使用%rax，编译器可能（很好）已经分配给其他东西......所以你实际上是“破坏”%rax但你没有告诉编译器这一点！
• 你指定的=r(X) (输出操作数）它告诉编译器期望某个寄存器中的输出，并且该输出将是变量的新值X. The %0 in the 汇编模板将被为输出选择的寄存器替换。可悲的是，你的大会对待%0作为输入:-( 而输出实际上是%rax-- 如上所述，编译器不知道这一点。

• 你还指定了r(X) (输入操作数) 告诉编译器安排变量的当前值X放置在某个寄存器中供汇编程序使用。这将是%1 in the 汇编模板。遗憾的是，您的程序集不使用此输入。

  即使输出和输入操作数都引用X，编译器可能不会使%0相同的寄存器%1。 （这允许它使用 asm 块作为非破坏性操作，使输入的原始值保持不变。如果这不是您的模板的工作方式，请不要那样编写。

• 一般来说你不需要volatile当所有输入和输出都通过约束正确描述时。编译器要做的一件好事就是丢弃asm()如果（所有）输出未被使用...volatile告诉编译器不要这样做（并告诉它许多其他事情......请参阅手册）。

除此之外，一切都很棒。以下是安全的，并且避免了mov操作说明：

 asm("rol %0\n"
     "rol %0\n"   : "+r"(X));

where "+r"(X)表示需要一个组合的输入和输出寄存器，取旧值X并退回一件新的。

现在，如果您不想更换X，然后假设Y是结果，你可以：

 asm("mov %1, %0\n"
     "rol %0\n"
     "rol %0\n"   : "=r"(Y) : "r"(X));

但最好让编译器来决定是否需要mov或者是否可以让输入被销毁。

有几条规则输入操作数值得一提的是：

• 汇编器must not覆盖任何输入操作数-- 编译器正在跟踪哪些值在哪些寄存器中，并且期望输入操作数予以保存。

• 编译器期望所有输入操作数之前要读的any 输出操作数被写。当编译器知道给定的输入操作数后不再使用asm()，因此它可以分配输入操作数的注册到输出操作数。有一种东西叫早起的 (=&r(foo)）来处理这个小皱纹。

在上面，如果你实际上没有使用X编译器可以再次分配%0 and %1到同一个寄存器！但是（多余的）mov仍然会被汇编——记住编译器真的不理解汇编模板。所以，一般来说，你最好在 C 中调整值，而不是在 C 中调整值。asm(). See https://gcc.gnu.org/wiki/DontUseInlineAsm https://gcc.gnu.org/wiki/DontUseInlineAsm and C++ 循环移位（旋转）操作的最佳实践 https://stackoverflow.com/q/776508

所以这里有一个主题的四种变体，以及生成的代码（gcc -O2）：

// (1) uses both X and Y in the printf() -- does mov %1, %0 in asm()
void Never_Inline footle(void)               Dump of assembler code for function footle:
{                                              mov    $0x492782,%edi   # address of format string
  unsigned long  X, Y ;                        xor    %eax,%eax
                                               mov    $0x63,%esi       # X = 99
  X = 99 ;                                     rol    %rsi            # 1st asm
  __asm__("\t rol  %0\n"                       rol    %rsi
          "\t rol  %0\n" : "+r"(X)             mov    %rsi,%rdx       # 2nd asm, compiler using it as a copy-and-rotate
      ) ;                                      rol    %rdx
                                               rol    %rdx
  __asm__("\t mov  %1, %0\n"                   jmpq   0x4010a0 <printf@plt>  # tailcall printf
          "\t rol  %0\n"
          "\t rol  %0\n" : "=r"(Y) : "r"(X)
      ) ;

  printf("%lx %lx\n", X, Y) ;
}

// (2) uses both X and Y in the printf() -- does Y = X in 'C'
void Never_Inline footle(void)               Dump of assembler code for function footle:
{                                              mov    $0x492782,%edi
  unsigned long  X, Y ;                        xor    %eax,%eax
                                               mov    $0x63,%esi
  X = 99 ;                                     rol    %rsi       # 1st asm
  __asm__("\t rol  %0\n"                       rol    %rsi
          "\t rol  %0\n" : "+r"(X)             mov    %rsi,%rdx  # compiler-generated mov
      ) ;                                      rol    %rdx       # 2nd asm
                                               rol    %rdx
  Y = X ;                                      jmpq   0x4010a0 <printf@plt>
  __asm__("\t rol  %0\n"
          "\t rol  %0\n" : "+r"(Y)
      ) ;

  printf("%lx %lx\n", X, Y) ;
}

// (3) uses only Y in the printf() -- does mov %1, %0 in asm()
void Never_Inline footle(void)               Dump of assembler code for function footle:
{                                              mov    $0x492782,%edi
  unsigned long  X, Y ;                        xor    %eax,%eax
                                               mov    $0x63,%esi
  X = 99 ;                                     rol    %rsi
  __asm__("\t rol  %0\n"                       rol    %rsi
          "\t rol  %0\n" : "+r"(X)             mov    %rsi,%rsi   # redundant instruction because of mov in the asm template
      ) ;                                      rol    %rsi
                                               rol    %rsi
  __asm__("\t mov  %1, %0\n"                   jmpq   0x4010a0 <printf@plt>
          "\t rol  %0\n"
          "\t rol  %0\n" : "=r"(Y) : "r"(X)
      ) ;

  printf("%lx\n", Y) ;
}

// (4) uses only Y in the printf() -- does Y = X in 'C'
void Never_Inline footle(void)               Dump of assembler code for function footle:
{                                              mov    $0x492782,%edi
  unsigned long  X, Y ;                        xor    %eax,%eax
                                               mov    $0x63,%esi
  X = 99 ;                                     rol    %rsi
  __asm__("\t rol  %0\n"                       rol    %rsi
          "\t rol  %0\n" : "+r"(X)             rol    %rsi    # no wasted mov, compiler picked %0=%1=%rsi
      ) ;                                      rol    %rsi
                                               jmpq   0x4010a0 <printf@plt>
  Y = X ;
  __asm__("\t rol  %0\n"
          "\t rol  %0\n" : "+r"(Y)
      ) ;

  printf("%lx\n", Y) ;
}

希望这能演示编译器忙于将值分配给寄存器，跟踪需要保留的值，最小化寄存器/寄存器移动，并且通常很聪明。

所以诀窍是与编译器一起工作，了解:输出操作数:输入操作数:Clobbers是您描述汇编器正在做什么的地方。