Question

找到以下内联汇编器code以计算向量叉积：

float32x4_t cross_test( const float32x4_t& lhs, const float32x4_t& rhs )
{
    float32x4_t result;

    asm volatile(
    "vext.8 d6, %e2, %f2, #4 \n\t"          
    "vext.8 d7, %e1, %f1, #4 \n\t"  
    "vmul.f32 %e0, %f1, %e2  \n\t" 
    "vmul.f32 %f0, %e1, d6   \n\t" 
    "vmls.f32 %e0, %f2, %e1  \n\t" 
    "vmls.f32 %f0, %e2, d7   \n\t" 
    "vext.8 %e0, %f0, %e0, #4    "      
    : "+w" ( result )                  
    : "w" ( lhs ), "w" ( rhs )            
    : "d6", "d7" );

    return result;
}

e之后的修饰符f和'%'是什么意思（例如%e2）？我找不到任何参考。

这是gcc生成的汇编代码：

vext.8 d6, d20, d21, #4 
vext.8 d7, d18, d19, #4 
vmul.f32 d16, d19, d20  
vmul.f32 d17, d18, d6   
vmls.f32 d16, d21, d18  
vmls.f32 d17, d20, d7   
vext.8 d16, d17, d16, #4

我现在了解了所用修饰词的含义。现在，我尝试遵循叉积算法。为此，我在汇编代码中添加了一些其他注释，但结果不符合我的期望：

    // History:
    // - '%e'  = lower register part
    // - '%f'  = higher register part
    // - '%?0' = res = [ x2 y2 | z2 v2 ]
    // - '%?1' = lhs = [ x0 y0 | z0 v0 ]
    // - '%?2' = rhs = [ x1 y1 | z1 v1 ]
    // - '%e0'       = [ x2 y2 ]
    // - '%f0'       = [ z2 v2 ]
    // - '%e1'       = [ x0 y0 ]
    // - '%f1'       = [ z0 v0 ]
    // - '%e2'       = [ x1 y1 ]
    // - '%f2'       = [ z1 v1 ]
    // Implemented algorithm:
    // |x2|   |y0 * z1 - z0 * y1|
    // |y2| = |z0 * x1 - x0 * z1|
    // |z2|   |x0 * y1 - y0 * x1|
    asm (
    "vext.8 d6, %e2, %f2, #4 \n\t" // e2=[ x1 y1 ], f2=[ z1 v1 ] -> d6=[ v1 x1 ]
    "vext.8 d7, %e1, %f1, #4 \n\t" // e1=[ x0 y0 ], f1=[ z0 v0 ] -> d7=[ v0 x0 ]
    "vmul.f32 %e0, %f1, %e2  \n\t" // f1=[ z0 v0 ], e2=[ x1 y1 ] -> e0=[ z0 * x1, v0 * y1 ]
    "vmul.f32 %f0, %e1, d6   \n\t" // e1=[ x0 y0 ], d6=[ v1 x1 ] -> f0=[ x0 * v1, y0 * x1 ]
    "vmls.f32 %e0, %f2, %e1  \n\t" // f2=[ z1 v1 ], e1=[ x0 y0 ] -> e0=[ z0 * x1 - z1 * x0, v0 * y1 - v1 * y0 ] = [ y2, - ]
    "vmls.f32 %f0, %e2, d7   \n\t" // e2=[ x1 y1 ], d7=[ v0 x0 ] -> f0=[ x0 * v1 - x1 * v0, y0 * x1 - y1 * x0 ] = [  -, - ]
    "vext.8 %e0, %f0, %e0, #4    " // 
    : "+w" ( result )              // Output section: 'w'='VFP floating point register', '+'='read/write'
    : "w" ( lhs ), "w" ( rhs )     // Input section : 'w'='VFP floating point register'
    : "d6", "d7" );                // Temporary 64[bit] register.

Answer 1

首先，这很奇怪。 result未在asm语句之前初始化，但已与"+w" ( result )一起用作输入/输出操作数。我认为"=w" (result)会更好。这是volatile也没有意义；输出是输入的纯函数，没有副作用或对任何“隐藏”输入的依赖，因此相同的输入每次都会给出相同的结果。因此，省略volatile将允许编译器对其进行CSE并在可能的情况下将其提升到循环外，而不是在每次源使用相同的输入运行它时都强制其重新计算。

我也找不到任何参考； gcc手册的“扩展ASM”页面仅记录operand modifiers for x86，而不记录ARM。

但是我认为我们可以通过查看asm输出来看到操作数修饰符：

%e0替换为d16，%f0替换为d17。 %e1是d18，而%f1是d19。 %2在d20和d21

中

您的输入是q寄存器中的16字节NEON向量。在ARM32中，每个q寄存器的上半部分和下半部分可以作为d寄存器单独访问。（与AArch64不同，其中每个s / d寄存器是不同q reg的底部元素。）看起来此代码利用此优势通过在{{1的高和低对上使用64位SIMD }}，经过4字节float混洗以混合这些成对的浮点数。

vext是操作数的低%e[operand]寄存器，d是高%f[operand]寄存器。没有记录，但是gcc源代码说（在gcc/config/arm/arm.c#L22486中的d中：

这两个代码打印一个霓虹灯四边形的低/高双字寄存器分别注册。对于成对结构类型，还可以打印低/高四字寄存器。

如果您将这些修饰符应用于诸如arm_print_operand之类的64位操作数，我没有测试会发生什么，而这全都是我从一个示例进行反向工程而来。但这是完全可以的修饰符。

x86修饰符包括一个用于整数寄存器的低8位和高8位（因此，如果在EAX中输入，则可以得到AL / AH），因此，部分寄存器的确是GNU C内联asm操作数修饰符可以执行的操作

请注意，未记录意味着不支持。

Answer 2

我正在寻找%e0和%f0的含义，该主题非常有帮助。 cross_test()的输出可以解释如下：

#include <arm_neon.h>
#include <stdio.h>

float32x4_t cross_test(const float32x4_t& lhs, const float32x4_t& rhs) {
  float32x4_t result;

  //   | f           | e
  // -----------------------------
  // 1 | a3(4) a2(3) | a1(2) a0(1)
  // 2 | b3(5) b2(6) | b1(7) b0(8)
  asm volatile (
    "vext.8 d6, %e1, %f1, #4"  "\n" // a2, a1
    "vext.8 d7, %e2, %f2, #4"  "\n" // b2, b1
    "vmul.f32 %e0, %f1, %e2"   "\n" // a3*b1, a2*b0
    "vmul.f32 %f0, %e1, d7"    "\n" // a1*b2, a0*b1
    "vmls.f32 %e0, %f2, %e1"   "\n" // a3*b1-a1*b3(18), a2*b0-a0*b2(18)
    "vmls.f32 %f0, %e2, d6"    "\n" // a1*b2-a2*b1(-9), a0*b1-a1*b0(-9)
    "vext.8 %e0, %f0, %e0, #4" "\n" // a2*b0-a0*b2(18), a1*b2-a2*b1(-9)
    : "+w"(result) // %0
    : "w"(lhs),    // %1
      "w"(rhs)     // %2
    : "d6", "d7"
  );

  return result;
}

#define nforeach(i, count) \
  for (int i = 0, __count = static_cast<int>(count); i < __count; ++i)

#define dump_f128(qf) do {                    \
  float *fp = reinterpret_cast<float *>(&qf); \
  puts(#qf ":");                              \
  nforeach(i, 4) {                            \
    printf("[%d]%f\n", i, fp[i]);             \
  }                                           \
} while (0)

int main() {
  float fa[] = {1., 2., 3., 4.};
  float fb[] = {8., 7., 6., 5.};

  float32x4_t qa, qb, qres;

  qa = vld1q_f32(const_cast<const float *>(&fa[0]));
  qb = vld1q_f32(const_cast<const float *>(&fb[0]));

  qres = cross_test(qa, qb);

  dump_f128(qa);
  puts("---");
  dump_f128(qb);
  puts("---");

  // -9, 18, -9, -9
  dump_f128(qres);

  return 0;
}

是否为16字节NEON操作数使用gcc arm内联汇编程序％e0和％f0操作数修饰符？

2 个答案: