-1

我很习惯 Intel 格式的内联汇编。有谁知道如何在下面的代码中将两条 AT&T 行转换为 Intel 格式？它基本上是将局部变量的地址加载到寄存器中。

int main(int argc, const char *argv[]){
    float x1[256];
    float x2[256];

    for(int x=0; x<256; ++x){
        x1[x] = x;
        x2[x] = 0.5f;
    }

    asm("movq %0, %%rax"::"r"(&x1[0])); // how to convert to Intel format?
    asm("movq %0, %%rbx"::"r"(&x2[0])); // how to convert to Intel format?

    asm(".intel_syntax noprefix\n"
        "mov rcx, 32\n"
"re:\n"
        "vmovups ymm0, [rax]\n"
        "vmovups ymm1, [rbx]\n"
        "vaddps ymm0, ymm0, ymm1\n"
        "vmovups [rax], ymm0\n"
        "add rax, 32\n"
        "add rbx, 32\n"
        "loopnz re"
    );
}

mov eax, [var_a]具体来说，在 32 位模式下编译时允许使用加载堆栈上的局部变量。例如，

// a32.cpp
#include <stdint.h>
extern "C" void f(){
    int32_t a=123;
    asm(".intel_syntax noprefix\n"
        "mov eax, [a]"
    );
}

它编译得很好：

xuancong@ubuntu:~$ rm -f a32.so && g++-7 -mavx -fPIC -masm=intel -shared -o a32.so -m32 a32.cpp && ls -al a32.so
-rwxr-xr-x 1 501 dialout 6580 Aug 28 09:26 a32.so

但是，在 64 位模式下编译时不允许使用相同的语法：

// a64.cpp
#include <stdint.h>
extern "C" void f(){
    int64_t a=123;
    asm(".intel_syntax noprefix\n"
        "mov rax, [a]"
    );
}

它不编译：

xuancong@ubuntu:~$ rm -f a64.so && g++-7 -mavx -fPIC -masm=intel -shared -o a64.so -m64 a64.cpp && ls -al a64.so
/usr/bin/ld: /tmp/cclPNMoq.o: relocation R_X86_64_32S against undefined symbol `a' can not be used when making a shared object; recompile with -fPIC
/usr/bin/ld: final link failed: Nonrepresentable section on output
collect2: error: ld returned 1 exit status

那么有什么方法可以在不使用的情况下完成这项工作，因为可以通过或不破坏其他寄存器input:output:clobber直接访问简单的局部变量或函数参数？mov rax, [rsp+##]mov rax, [rbp+##]

4

1 回答 1

0

太好了，让我们看看测试结果：

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <time.h>
#include <immintrin.h>

#define N 256000000
using namespace std;

void f1a(float *a, float *b, int64_t n){
    asm("movq %0, %%rax"::"r"(a));
    asm("movq %0, %%rbx"::"r"(b));
    asm("movq %0, %%rcx"::"r"(n));

    asm(".intel_syntax noprefix\n"
        "shr rcx, 3\n"
"re:\n"
        "vmovaps ymm0, [rax]\n"
        "vmovaps ymm1, [rbx]\n"
        "vaddps ymm0, ymm0, ymm1\n"
        "vmovaps [rax], ymm0\n"
        "add rax, 32\n"
        "add rbx, 32\n"
        "loopnz re"
    );
}

void f1b(float *a, float *b, int64_t n){
    asm("movq %0, %%rax"::"r"(a));
    asm("movq %0, %%rbx"::"r"(b));
    asm("movq %0, %%rcx"::"r"(n));

    asm(".intel_syntax noprefix\n"
        "shr rcx, 3\n"
"re1:\n"
        "vmovaps ymm0, [rax]\n"
        "vmovaps ymm1, [rbx]\n"
        "vaddps ymm0, ymm0, ymm1\n"
        "vmovaps [rax], ymm0\n"
        "add rax, 32\n"
        "add rbx, 32\n"
        "dec rcx\n"
        "jnz re1"
    );
}

void f1c(float *a, float *b, int64_t n){
    asm("movq %0, %%rax"::"r"(a));
    asm("movq %0, %%rbx"::"r"(b));
    asm("movq %0, %%rcx"::"r"(n));

    asm(".intel_syntax noprefix\n"
"re2:\n"
        "sub rcx, 8\n"
        "vmovaps ymm0, [rax+rcx*4]\n"
        "vmovaps ymm1, [rbx+rcx*4]\n"
        "vaddps ymm0, ymm0, ymm1\n"
        "vmovaps [rax+rcx*4], ymm0\n"
        "jnz re2"
    );
}

void f2a(float *a, float *b, int64_t n){
    for(int i=n-8; i>=0; i-=8) {
        __m256 x8 = _mm256_load_ps(&a[i]);
        __m256 y8 = _mm256_load_ps(&b[i]);
        __m256 s = _mm256_add_ps(x8, y8);
        _mm256_store_ps(&a[i], s);
    }
}

void f2b(float *a, float *b, int64_t n){
    for(int i=(n>>3)-1; i>=0; --i) {
        __m256 x8 = _mm256_load_ps(&a[i*8]);
        __m256 y8 = _mm256_load_ps(&b[i*8]);
        __m256 s = _mm256_add_ps(x8, y8);
        _mm256_store_ps(&a[i*8], s);
    }
}

void f3(float *a, float *b, int64_t n){
    for(int i=n-1; i>=0; --i)
        a[i] += b[i];
}

void test(float *a, float *b, void(*func)(float*, float*, int64_t), char *name){
    clock_t t;
    printf("Testing %s():", name); fflush(stdout);
    t = clock();
    func(a, b, N);
    printf("%lu\n", clock()-t); fflush(stdout);
}

alignas(64) float x1[N];
alignas(64) float x2[N];

int main(int argc, const char *argv[]){
    printf("Preparing buffer ...");
    fflush(stdout);
    for(int x=0; x<N; ++x){
        x1[x] = x/10.0f;
        x2[x] = 0.5f+1.0f/(x+1);
    }
    printf("Done!\n");
    fflush(stdout);

    test(x1, x2, f3, "warm-up-cache");
    test(x1, x2, f1a, "f1a");
    test(x1, x2, f1b, "f1b");
    test(x1, x2, f1c, "f1c");
    test(x1, x2, f2a, "f2a");
    test(x1, x2, f2b, "f2b");
    test(x1, x2, f3, "f3");

    return 0;
}

输出：

Preparing buffer ...Done!
Testing warm-up-cache():551638
Testing f1a():179409
Testing f1b():159309
Testing f1c():172496
Testing f2a():247539
Testing f2b():245975
Testing f3():520559

由于内联汇编不能用-O3 编译，所以我注释掉了f1* 并用-O3 编译。O3-测试结果如下：

Testing warm-up-cache():233775
Testing f2a():170199
Testing f2b():187909
Testing f3():181979

在这个简单的例子中，改进并不是那么显着。但是，仍然不存在 OP 的解决方案。建议的重复帖子不包含 64 位 Intel 格式的解决方案。

于 2020-08-25T12:02:48.123 回答