使用内联汇编遍历数组
Looping over arrays with inline assembly
当使用内联汇编遍历数组时，我应该使用寄存器修饰符 "r" 还是内存修饰符 "m"?
让我们考虑一个例子，将两个浮点数组 x 和 y 相加并将结果写入 z。通常我会使用内在函数来这样做
for(int i=0; i<n/4; i++) {
__m128 x4 = _mm_load_ps(&x[4*i]);
__m128 y4 = _mm_load_ps(&y[4*i]);
__m128 s = _mm_add_ps(x4,y4);
_mm_store_ps(&z[4*i], s);
}
这是我使用寄存器修饰符想出的内联汇编解决方案"r"
void add_asm1(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%1,%%rax,4), %%xmm0\n"
"addps (%2,%%rax,4), %%xmm0\n"
"movaps %%xmm0, (%0,%%rax,4)\n"
:
: "r" (z), "r" (y), "r" (x), "a" (i)
:
);
}
}
这会生成与 GCC 类似的程序集。主要区别在于 GCC 将 16 添加到索引寄存器并使用 1 的比例，而内联汇编解决方案将 4 添加到索引寄存器并使用 4.
我无法为迭代器使用通用寄存器。我必须指定一个，在本例中是 rax。这有什么原因吗？
这是我使用内存修改器想出的解决方案 "m"
void add_asm2(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps %1, %%xmm0\n"
"addps %2, %%xmm0\n"
"movaps %%xmm0, %0\n"
: "=m" (z[i])
: "m" (y[i]), "m" (x[i])
:
);
}
}
这种方法效率较低，因为它不使用索引寄存器，而是必须将 16 添加到每个数组的基址寄存器。生成的程序集是 (gcc (Ubuntu 5.2.1-22ubuntu2) with gcc -O3 -S asmtest.c):
.L22
movaps (%rsi), %xmm0
addps (%rdi), %xmm0
movaps %xmm0, (%rdx)
addl , %eax
addq , %rdx
addq , %rsi
addq , %rdi
cmpl %eax, %ecx
ja .L22
使用内存修饰符"m"是否有更好的解决方案？有没有办法让它使用索引寄存器？ 我问的原因是使用内存修饰符 "m" 对我来说似乎更合乎逻辑，因为我正在读写内存。此外，使用寄存器修饰符 "r" 我从不使用起初对我来说很奇怪的输出操作数列表。
也许有比使用 "r" 或 "m" 更好的解决方案？
这是我用来测试这个的完整代码
#include <stdio.h>
#include <x86intrin.h>
#define N 64
void add_intrin(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__m128 x4 = _mm_load_ps(&x[i]);
__m128 y4 = _mm_load_ps(&y[i]);
__m128 s = _mm_add_ps(x4,y4);
_mm_store_ps(&z[i], s);
}
}
void add_intrin2(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n/4; i++) {
__m128 x4 = _mm_load_ps(&x[4*i]);
__m128 y4 = _mm_load_ps(&y[4*i]);
__m128 s = _mm_add_ps(x4,y4);
_mm_store_ps(&z[4*i], s);
}
}
void add_asm1(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%1,%%rax,4), %%xmm0\n"
"addps (%2,%%rax,4), %%xmm0\n"
"movaps %%xmm0, (%0,%%rax,4)\n"
:
: "r" (z), "r" (y), "r" (x), "a" (i)
:
);
}
}
void add_asm2(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps %1, %%xmm0\n"
"addps %2, %%xmm0\n"
"movaps %%xmm0, %0\n"
: "=m" (z[i])
: "m" (y[i]), "m" (x[i])
:
);
}
}
int main(void) {
float x[N], y[N], z1[N], z2[N], z3[N];
for(int i=0; i<N; i++) x[i] = 1.0f, y[i] = 2.0f;
add_intrin2(x,y,z1,N);
add_asm1(x,y,z2,N);
add_asm2(x,y,z3,N);
for(int i=0; i<N; i++) printf("%.0f ", z1[i]); puts("");
for(int i=0; i<N; i++) printf("%.0f ", z2[i]); puts("");
for(int i=0; i<N; i++) printf("%.0f ", z3[i]); puts("");
}
当我用 gcc (4.9.2) 编译您的 add_asm2 代码时，我得到：
add_asm2:
.LFB0:
.cfi_startproc
xorl %eax, %eax
xorl %r8d, %r8d
testl %ecx, %ecx
je .L1
.p2align 4,,10
.p2align 3
.L5:
#APP
# 3 "add_asm2.c" 1
movaps (%rsi,%rax), %xmm0
addps (%rdi,%rax), %xmm0
movaps %xmm0, (%rdx,%rax)
# 0 "" 2
#NO_APP
addl , %r8d
addq , %rax
cmpl %r8d, %ecx
ja .L5
.L1:
rep; ret
.cfi_endproc
所以它并不完美（它使用了冗余寄存器），但确实使用了索引加载...
gcc 还有 builtin vector extensions 甚至是跨平台的：
typedef float v4sf __attribute__((vector_size(16)));
void add_vector(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n/4; i+=1) {
*(v4sf*)(z + 4*i) = *(v4sf*)(x + 4*i) + *(v4sf*)(y + 4*i);
}
}
在我的 gcc 版本 4.7.2 上生成的程序集是：
.L28:
movaps (%rdi,%rax), %xmm0
addps (%rsi,%rax), %xmm0
movaps %xmm0, (%rdx,%rax)
addq , %rax
cmpq %rcx, %rax
jne .L28
尽可能避免内联汇编：https://gcc.gnu.org/wiki/DontUseInlineAsm。它阻止了许多优化。但是，如果您真的不能让编译器生成您想要的 asm，您可能应该在 asm 中编写整个循环，这样您就可以手动展开和调整它，而不是像这样做。
您可以对索引使用 r 约束。使用 q 修饰符获取 64 位寄存器的名称，因此您可以在寻址模式下使用它。为 32 位目标编译时，q 修饰符选择 32 位寄存器的名称，因此相同的代码仍然有效。
如果你想选择使用哪种寻址模式，你需要自己做，使用具有r约束的指针操作数。
GNU C 内联 asm 语法不假定您读取或写入指针操作数指向的内存。 （例如，也许您正在对指针值使用内联汇编 and）。所以你需要用 "memory" clobber 或内存 input/output 操作数做一些事情，让它知道你修改了什么内存。 "memory" 破坏很容易，但强制除本地以外的所有内容都是 spilled/reloaded。有关使用虚拟输入操作数的示例，请参阅 Clobbers section in the docs。
具体来说，一个"m" (*(const float (*)[]) fptr)会告诉编译器整个数组对象是一个输入，任意长度。即 asm 不能对任何使用 fptr 作为地址一部分的存储（或使用它已知指向的数组）进行重新排序。也适用于 "=m" 或 "+m" 约束（显然没有 const）。
使用 特定大小，例如 "m" (*(const float (*)[4]) fptr) 可以让您告诉编译器您 do/don 没有阅读的内容。 （或写）。然后它 可以 （如果另外允许）将存储下沉到 asm 语句后面的元素，并将它与另一个存储组合（或进行死存储消除）任何存储您的内联 asm 未读取的内容。
（有关此问题的完整问答，请参阅 。）
m 约束的另一个巨大好处是 -funroll-loops 可以通过生成具有恒定偏移量的地址来工作。自己进行寻址可以防止编译器每 4 次迭代或其他操作进行一次递增，因为 i 的每个源代码级值都需要出现在寄存器中。
这是我的版本，有一些调整，如评论中所述。这不是最佳的，例如编译器无法有效展开。
#include <immintrin.h>
void add_asm1_memclobber(float *x, float *y, float *z, unsigned n) {
__m128 vectmp; // let the compiler choose a scratch register
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%[y],%q[idx],4), %[vectmp]\n\t" // q modifier: 64bit version of a GP reg
"addps (%[x],%q[idx],4), %[vectmp]\n\t"
"movaps %[vectmp], (%[z],%q[idx],4)\n\t"
: [vectmp] "=x" (vectmp) // "=m" (z[i]) // gives worse code if the compiler prepares a reg we don't use
: [z] "r" (z), [y] "r" (y), [x] "r" (x),
[idx] "r" (i) // unrolling is impossible this way (without an insn for every increment by 4)
: "memory"
// you can avoid a "memory" clobber with dummy input/output operands
);
}
}
Godbolt compiler explorer 此版本和以下几个版本的 asm 输出。
您的版本需要将 %xmm0 声明为已损坏，否则在内联时您会遇到麻烦。我的版本使用临时变量作为从未使用过的仅输出操作数。这使编译器可以完全自由地分配寄存器。
如果你想避免“内存”破坏，你可以使用虚拟内存input/output操作数，比如"m" (*(const __m128*)&x[i])来告诉编译器哪个内存是由您的函数读取和写入。如果您在 运行 循环之前执行了类似 x[4] = 1.0; 的操作，这对于确保正确的代码生成是必要的。 （即使你没有写那么简单的东西，内联和常量传播也可以将其归结为那个。）还要确保编译器在循环运行之前不会从 z[] 中读取。
在这种情况下，我们得到了可怕的结果：gcc5.x 实际上增加了 3 个额外的指针，因为它决定使用 [reg] 寻址模式而不是索引模式。它不知道内联汇编实际上从未使用约束创建的寻址模式引用那些内存操作数！
# gcc5.4 with dummy constraints like "=m" (*(__m128*)&z[i]) instead of "memory" clobber
.L11:
movaps (%rsi,%rax,4), %xmm0 # y, i, vectmp
addps (%rdi,%rax,4), %xmm0 # x, i, vectmp
movaps %xmm0, (%rdx,%rax,4) # vectmp, z, i
addl , %eax #, i
addq , %r10 #, ivtmp.19
addq , %r9 #, ivtmp.21
addq , %r8 #, ivtmp.22
cmpl %eax, %ecx # i, n
ja .L11 #,
r8、r9 和 r10 是内联 asm 块不使用的额外指针。
您可以使用一个约束告诉 gcc 任意长度的整个数组是输入还是输出："m" (*(const char (*)[]) pStr)。这会将指针转换为指向数组的指针（未指定大小）。参见
如果我们想使用索引寻址模式，我们将在寄存器中拥有所有三个数组的基地址，这种形式的约束要求（整个数组的）基地址作为操作数，而不是指向正在操作的当前内存的指针。
这实际上在循环内没有任何额外的指针或计数器增量的情况下工作：（避免了 "memory" 破坏，但仍然不容易被编译器展开）。
void add_asm1_dummy_whole_array(const float *restrict x, const float *restrict y,
float *restrict z, unsigned n) {
__m128 vectmp; // let the compiler choose a scratch register
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%[y],%q[idx],4), %[vectmp]\n\t" // q modifier: 64bit version of a GP reg
"addps (%[x],%q[idx],4), %[vectmp]\n\t"
"movaps %[vectmp], (%[z],%q[idx],4)\n\t"
: [vectmp] "=x" (vectmp)
, "=m" (*(float (*)[]) z) // "=m" (z[i]) // gives worse code if the compiler prepares a reg we don't use
: [z] "r" (z), [y] "r" (y), [x] "r" (x),
[idx] "r" (i) // unrolling is impossible this way (without an insn for every increment by 4)
, "m" (*(const float (*)[]) x),
"m" (*(const float (*)[]) y) // pointer to unsized array = all memory from this pointer
);
}
}
这给了我们与 "memory" clobber 相同的内部循环：
.L19: # with clobbers like "m" (*(const struct {float a; float x[];} *) y)
movaps (%rsi,%rax,4), %xmm0 # y, i, vectmp
addps (%rdi,%rax,4), %xmm0 # x, i, vectmp
movaps %xmm0, (%rdx,%rax,4) # vectmp, z, i
addl , %eax #, i
cmpl %eax, %ecx # i, n
ja .L19 #,
它告诉编译器每个 asm 块读取或写入整个数组，因此它可能会不必要地阻止它与其他代码交错（例如，在以低迭代次数完全展开之后）。它不会停止展开，但是将每个索引值都保存在寄存器中的要求确实降低了它的效率。在同一循环中此块的第二个副本中无法以 16(%rsi,%rax,4) 寻址模式结束，因为我们对编译器隐藏了寻址。
具有 m 约束的版本，that gcc can unroll:
#include <immintrin.h>
void add_asm1(float *x, float *y, float *z, unsigned n) {
// x, y, z are assumed to be aligned
__m128 vectmp; // let the compiler choose a scratch register
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
// "movaps %[yi], %[vectmp]\n\t" // get the compiler to do this load instead
"addps %[xi], %[vectmp]\n\t"
"movaps %[vectmp], %[zi]\n\t"
// __m128 is a may_alias type so these casts are safe.
: [vectmp] "=x" (vectmp) // let compiler pick a stratch reg
,[zi] "=m" (*(__m128*)&z[i]) // actual memory output for the movaps store
: [yi] "0" (*(__m128*)&y[i]) // or [yi] "xm" (*(__m128*)&y[i]), and uncomment the movaps load
,[xi] "xm" (*(__m128*)&x[i])
//, [idx] "r" (i) // unrolling with this would need an insn for every increment by 4
);
}
}
使用 [yi] 作为 +x input/output 操作数会更简单，但以这种方式编写它对取消注释内联 asm 中的负载所做的更改较小，而不是让编译器为我们取一个值到寄存器中。
当使用内联汇编遍历数组时，我应该使用寄存器修饰符 "r" 还是内存修饰符 "m"?
让我们考虑一个例子，将两个浮点数组 x 和 y 相加并将结果写入 z。通常我会使用内在函数来这样做
for(int i=0; i<n/4; i++) {
__m128 x4 = _mm_load_ps(&x[4*i]);
__m128 y4 = _mm_load_ps(&y[4*i]);
__m128 s = _mm_add_ps(x4,y4);
_mm_store_ps(&z[4*i], s);
}
这是我使用寄存器修饰符想出的内联汇编解决方案"r"
void add_asm1(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%1,%%rax,4), %%xmm0\n"
"addps (%2,%%rax,4), %%xmm0\n"
"movaps %%xmm0, (%0,%%rax,4)\n"
:
: "r" (z), "r" (y), "r" (x), "a" (i)
:
);
}
}
这会生成与 GCC 类似的程序集。主要区别在于 GCC 将 16 添加到索引寄存器并使用 1 的比例，而内联汇编解决方案将 4 添加到索引寄存器并使用 4.
我无法为迭代器使用通用寄存器。我必须指定一个，在本例中是 rax。这有什么原因吗？
这是我使用内存修改器想出的解决方案 "m"
void add_asm2(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps %1, %%xmm0\n"
"addps %2, %%xmm0\n"
"movaps %%xmm0, %0\n"
: "=m" (z[i])
: "m" (y[i]), "m" (x[i])
:
);
}
}
这种方法效率较低，因为它不使用索引寄存器，而是必须将 16 添加到每个数组的基址寄存器。生成的程序集是 (gcc (Ubuntu 5.2.1-22ubuntu2) with gcc -O3 -S asmtest.c):
.L22
movaps (%rsi), %xmm0
addps (%rdi), %xmm0
movaps %xmm0, (%rdx)
addl , %eax
addq , %rdx
addq , %rsi
addq , %rdi
cmpl %eax, %ecx
ja .L22
使用内存修饰符"m"是否有更好的解决方案？有没有办法让它使用索引寄存器？ 我问的原因是使用内存修饰符 "m" 对我来说似乎更合乎逻辑，因为我正在读写内存。此外，使用寄存器修饰符 "r" 我从不使用起初对我来说很奇怪的输出操作数列表。
也许有比使用 "r" 或 "m" 更好的解决方案？
这是我用来测试这个的完整代码
#include <stdio.h>
#include <x86intrin.h>
#define N 64
void add_intrin(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__m128 x4 = _mm_load_ps(&x[i]);
__m128 y4 = _mm_load_ps(&y[i]);
__m128 s = _mm_add_ps(x4,y4);
_mm_store_ps(&z[i], s);
}
}
void add_intrin2(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n/4; i++) {
__m128 x4 = _mm_load_ps(&x[4*i]);
__m128 y4 = _mm_load_ps(&y[4*i]);
__m128 s = _mm_add_ps(x4,y4);
_mm_store_ps(&z[4*i], s);
}
}
void add_asm1(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%1,%%rax,4), %%xmm0\n"
"addps (%2,%%rax,4), %%xmm0\n"
"movaps %%xmm0, (%0,%%rax,4)\n"
:
: "r" (z), "r" (y), "r" (x), "a" (i)
:
);
}
}
void add_asm2(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps %1, %%xmm0\n"
"addps %2, %%xmm0\n"
"movaps %%xmm0, %0\n"
: "=m" (z[i])
: "m" (y[i]), "m" (x[i])
:
);
}
}
int main(void) {
float x[N], y[N], z1[N], z2[N], z3[N];
for(int i=0; i<N; i++) x[i] = 1.0f, y[i] = 2.0f;
add_intrin2(x,y,z1,N);
add_asm1(x,y,z2,N);
add_asm2(x,y,z3,N);
for(int i=0; i<N; i++) printf("%.0f ", z1[i]); puts("");
for(int i=0; i<N; i++) printf("%.0f ", z2[i]); puts("");
for(int i=0; i<N; i++) printf("%.0f ", z3[i]); puts("");
}
当我用 gcc (4.9.2) 编译您的 add_asm2 代码时，我得到：
add_asm2:
.LFB0:
.cfi_startproc
xorl %eax, %eax
xorl %r8d, %r8d
testl %ecx, %ecx
je .L1
.p2align 4,,10
.p2align 3
.L5:
#APP
# 3 "add_asm2.c" 1
movaps (%rsi,%rax), %xmm0
addps (%rdi,%rax), %xmm0
movaps %xmm0, (%rdx,%rax)
# 0 "" 2
#NO_APP
addl , %r8d
addq , %rax
cmpl %r8d, %ecx
ja .L5
.L1:
rep; ret
.cfi_endproc
所以它并不完美（它使用了冗余寄存器），但确实使用了索引加载...
gcc 还有 builtin vector extensions 甚至是跨平台的：
typedef float v4sf __attribute__((vector_size(16)));
void add_vector(float *x, float *y, float *z, unsigned n) {
for(int i=0; i<n/4; i+=1) {
*(v4sf*)(z + 4*i) = *(v4sf*)(x + 4*i) + *(v4sf*)(y + 4*i);
}
}
在我的 gcc 版本 4.7.2 上生成的程序集是：
.L28:
movaps (%rdi,%rax), %xmm0
addps (%rsi,%rax), %xmm0
movaps %xmm0, (%rdx,%rax)
addq , %rax
cmpq %rcx, %rax
jne .L28
尽可能避免内联汇编：https://gcc.gnu.org/wiki/DontUseInlineAsm。它阻止了许多优化。但是，如果您真的不能让编译器生成您想要的 asm，您可能应该在 asm 中编写整个循环，这样您就可以手动展开和调整它，而不是像这样做。
您可以对索引使用 r 约束。使用 q 修饰符获取 64 位寄存器的名称，因此您可以在寻址模式下使用它。为 32 位目标编译时，q 修饰符选择 32 位寄存器的名称，因此相同的代码仍然有效。
如果你想选择使用哪种寻址模式，你需要自己做，使用具有r约束的指针操作数。
GNU C 内联 asm 语法不假定您读取或写入指针操作数指向的内存。 （例如，也许您正在对指针值使用内联汇编 and）。所以你需要用 "memory" clobber 或内存 input/output 操作数做一些事情，让它知道你修改了什么内存。 "memory" 破坏很容易，但强制除本地以外的所有内容都是 spilled/reloaded。有关使用虚拟输入操作数的示例，请参阅 Clobbers section in the docs。
具体来说，一个"m" (*(const float (*)[]) fptr)会告诉编译器整个数组对象是一个输入，任意长度。即 asm 不能对任何使用 fptr 作为地址一部分的存储（或使用它已知指向的数组）进行重新排序。也适用于 "=m" 或 "+m" 约束（显然没有 const）。
使用 特定大小，例如 "m" (*(const float (*)[4]) fptr) 可以让您告诉编译器您 do/don 没有阅读的内容。 （或写）。然后它 可以 （如果另外允许）将存储下沉到 asm 语句后面的元素，并将它与另一个存储组合（或进行死存储消除）任何存储您的内联 asm 未读取的内容。
（有关此问题的完整问答，请参阅
m 约束的另一个巨大好处是 -funroll-loops 可以通过生成具有恒定偏移量的地址来工作。自己进行寻址可以防止编译器每 4 次迭代或其他操作进行一次递增，因为 i 的每个源代码级值都需要出现在寄存器中。
这是我的版本，有一些调整，如评论中所述。这不是最佳的，例如编译器无法有效展开。
#include <immintrin.h>
void add_asm1_memclobber(float *x, float *y, float *z, unsigned n) {
__m128 vectmp; // let the compiler choose a scratch register
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%[y],%q[idx],4), %[vectmp]\n\t" // q modifier: 64bit version of a GP reg
"addps (%[x],%q[idx],4), %[vectmp]\n\t"
"movaps %[vectmp], (%[z],%q[idx],4)\n\t"
: [vectmp] "=x" (vectmp) // "=m" (z[i]) // gives worse code if the compiler prepares a reg we don't use
: [z] "r" (z), [y] "r" (y), [x] "r" (x),
[idx] "r" (i) // unrolling is impossible this way (without an insn for every increment by 4)
: "memory"
// you can avoid a "memory" clobber with dummy input/output operands
);
}
}
Godbolt compiler explorer 此版本和以下几个版本的 asm 输出。
您的版本需要将 %xmm0 声明为已损坏，否则在内联时您会遇到麻烦。我的版本使用临时变量作为从未使用过的仅输出操作数。这使编译器可以完全自由地分配寄存器。
如果你想避免“内存”破坏，你可以使用虚拟内存input/output操作数，比如"m" (*(const __m128*)&x[i])来告诉编译器哪个内存是由您的函数读取和写入。如果您在 运行 循环之前执行了类似 x[4] = 1.0; 的操作，这对于确保正确的代码生成是必要的。 （即使你没有写那么简单的东西，内联和常量传播也可以将其归结为那个。）还要确保编译器在循环运行之前不会从 z[] 中读取。
在这种情况下，我们得到了可怕的结果：gcc5.x 实际上增加了 3 个额外的指针，因为它决定使用 [reg] 寻址模式而不是索引模式。它不知道内联汇编实际上从未使用约束创建的寻址模式引用那些内存操作数！
# gcc5.4 with dummy constraints like "=m" (*(__m128*)&z[i]) instead of "memory" clobber
.L11:
movaps (%rsi,%rax,4), %xmm0 # y, i, vectmp
addps (%rdi,%rax,4), %xmm0 # x, i, vectmp
movaps %xmm0, (%rdx,%rax,4) # vectmp, z, i
addl , %eax #, i
addq , %r10 #, ivtmp.19
addq , %r9 #, ivtmp.21
addq , %r8 #, ivtmp.22
cmpl %eax, %ecx # i, n
ja .L11 #,
r8、r9 和 r10 是内联 asm 块不使用的额外指针。
您可以使用一个约束告诉 gcc 任意长度的整个数组是输入还是输出："m" (*(const char (*)[]) pStr)。这会将指针转换为指向数组的指针（未指定大小）。参见
如果我们想使用索引寻址模式，我们将在寄存器中拥有所有三个数组的基地址，这种形式的约束要求（整个数组的）基地址作为操作数，而不是指向正在操作的当前内存的指针。
这实际上在循环内没有任何额外的指针或计数器增量的情况下工作：（避免了 "memory" 破坏，但仍然不容易被编译器展开）。
void add_asm1_dummy_whole_array(const float *restrict x, const float *restrict y,
float *restrict z, unsigned n) {
__m128 vectmp; // let the compiler choose a scratch register
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
"movaps (%[y],%q[idx],4), %[vectmp]\n\t" // q modifier: 64bit version of a GP reg
"addps (%[x],%q[idx],4), %[vectmp]\n\t"
"movaps %[vectmp], (%[z],%q[idx],4)\n\t"
: [vectmp] "=x" (vectmp)
, "=m" (*(float (*)[]) z) // "=m" (z[i]) // gives worse code if the compiler prepares a reg we don't use
: [z] "r" (z), [y] "r" (y), [x] "r" (x),
[idx] "r" (i) // unrolling is impossible this way (without an insn for every increment by 4)
, "m" (*(const float (*)[]) x),
"m" (*(const float (*)[]) y) // pointer to unsized array = all memory from this pointer
);
}
}
这给了我们与 "memory" clobber 相同的内部循环：
.L19: # with clobbers like "m" (*(const struct {float a; float x[];} *) y)
movaps (%rsi,%rax,4), %xmm0 # y, i, vectmp
addps (%rdi,%rax,4), %xmm0 # x, i, vectmp
movaps %xmm0, (%rdx,%rax,4) # vectmp, z, i
addl , %eax #, i
cmpl %eax, %ecx # i, n
ja .L19 #,
它告诉编译器每个 asm 块读取或写入整个数组，因此它可能会不必要地阻止它与其他代码交错（例如，在以低迭代次数完全展开之后）。它不会停止展开，但是将每个索引值都保存在寄存器中的要求确实降低了它的效率。在同一循环中此块的第二个副本中无法以 16(%rsi,%rax,4) 寻址模式结束，因为我们对编译器隐藏了寻址。
具有 m 约束的版本，that gcc can unroll:
#include <immintrin.h>
void add_asm1(float *x, float *y, float *z, unsigned n) {
// x, y, z are assumed to be aligned
__m128 vectmp; // let the compiler choose a scratch register
for(int i=0; i<n; i+=4) {
__asm__ __volatile__ (
// "movaps %[yi], %[vectmp]\n\t" // get the compiler to do this load instead
"addps %[xi], %[vectmp]\n\t"
"movaps %[vectmp], %[zi]\n\t"
// __m128 is a may_alias type so these casts are safe.
: [vectmp] "=x" (vectmp) // let compiler pick a stratch reg
,[zi] "=m" (*(__m128*)&z[i]) // actual memory output for the movaps store
: [yi] "0" (*(__m128*)&y[i]) // or [yi] "xm" (*(__m128*)&y[i]), and uncomment the movaps load
,[xi] "xm" (*(__m128*)&x[i])
//, [idx] "r" (i) // unrolling with this would need an insn for every increment by 4
);
}
}
使用 [yi] 作为 +x input/output 操作数会更简单，但以这种方式编写它对取消注释内联 asm 中的负载所做的更改较小，而不是让编译器为我们取一个值到寄存器中。