Арифметика с плавающей точкой в ​​синтаксисе AT & T

Question

По сути, все, что мне нужно сделать, это умножить матрицу на вектор, используя операции с плавающей запятой в сборке.

Мой первый набросок выглядит так:

  .data
  mat: .float 1.0, 2.0, 3.0, 4.0, 5.0, 6.0
  vek: .float 1.0, 2.0, 3.0
  res: .float 0.0, 0.0
  .text
  .globl main
  main:
  ; here goes the magic
  call exit

К сожалению, все, что я пробовал, не работает. Я знаю, как выполнять основные арифметические операции (например, faddp, fmulp и т. Д.), Но я до сих пор не могу их эффективно хранить. fstpl похоже не работает вообще.

Кто-нибудь может дать мне грубый набросок (не о том, как сделать эту матрицу - векторное умножение), как использовать команды FPU и как сохранить вычисленный результат в регистре?

Заранее спасибо,

Answer 1

Сначала внедрите его в C, протестируйте его, затем используйте gcc -S для генерации исходного кода на ассемблере, затем либо используйте как есть , либо используйте его в качестве шаблона для собственного кода.

Например, вот реализация кода на C, mat_vec.c:

#include <stdio.h>

int main(void)
{
    // note: use "volatile" qualifier for input data otherwise gcc will
    //       just optimise all the arithmetic away...
    volatile float mat[2][3] = { { 1.0f, 2.0f, 3.0f }, { 4.0f, 5.0f, 6.0f } };
    volatile float vek[3] = { 1.0f, 2.0f, 3.0f };
    float res[2] = { 0.0f, 0.0f };

    res[0] = mat[0][0] * vek[0] + mat[0][1] * vek[1] + mat[0][2] * vek[2]; 
    res[1] = mat[1][0] * vek[0] + mat[1][1] * vek[1] + mat[1][2] * vek[2]; 

    printf("res = { %g, %g }\n", res[0], res[1]);

    return 0;
}

Давайте удостоверимся, что это работает:

$ gcc -Wall -Os -m32 -march=i686 mat_vec.c -o mat_vec
$ ./mat_vec
res = { 14, 32 }
$

Хорошо выглядит, поэтому давайте сгенерируем исходный код на ассемблере:

$ gcc -Wall -Os -m32 -march=i686 -S mat_vec.c -o mat_vec.S
$ cat mat_vec.S
    .cstring
LC6:
    .ascii "res = { %g, %g }\12\0"
    .text
.globl _main
_main:
    pushl   %ebp
    movl    $0x40000000, %ecx
    movl    %esp, %ebp
    movl    $0x40400000, %edx
    pushl   %esi
    movl    $0x40800000, %eax
    pushl   %ebx
    movl    $0x3f800000, %esi
    subl    $96, %esp
    movl    %esi, -44(%ebp)
    movl    %ecx, -40(%ebp)
    movl    %edx, -36(%ebp)
    movl    %eax, -32(%ebp)
    movl    $0x40a00000, %eax
    movl    %eax, -28(%ebp)
    movl    $0x40c00000, %eax
    movl    %eax, -24(%ebp)
    movl    %esi, -20(%ebp)
    movl    %ecx, -16(%ebp)
    movl    %edx, -12(%ebp)
    flds    -44(%ebp)
    flds    -20(%ebp)
    fstps   -72(%ebp)
    flds    -40(%ebp)
    flds    -16(%ebp)
    fstps   -68(%ebp)
    flds    -36(%ebp)
    fstps   -64(%ebp)
    flds    -12(%ebp)
    fstps   -60(%ebp)
    flds    -32(%ebp)
    flds    -20(%ebp)
    flds    -28(%ebp)
    flds    -16(%ebp)
    fxch    %st(3)
    fmulp   %st, %st(2)
    flds    -24(%ebp)
    flds    -12(%ebp)
    fxch    %st(2)
    fmulp   %st, %st(4)
    call    L3
"L00000000001$pb":
L3:
    popl    %ebx
    fmulp   %st, %st(1)
    fxch    %st(3)
    fmuls   -68(%ebp)
    fxch    %st(1)
    faddp   %st, %st(2)
    fxch    %st(3)
    fmuls   -72(%ebp)
    fxch    %st(1)
    faddp   %st, %st(2)
    fxch    %st(1)
    leal    LC6-"L00000000001$pb"(%ebx), %eax
    fstpl   12(%esp)
    flds    -64(%ebp)
    fmuls   -60(%ebp)
    fxch    %st(1)
    faddp   %st, %st(2)
    faddp   %st, %st(1)
    fstpl   4(%esp)
    movl    %eax, (%esp)
    call    L_printf$stub
    addl    $96, %esp
    xorl    %eax, %eax
    popl    %ebx
    popl    %esi
    leave
    ret
    .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
L_printf$stub:
    .indirect_symbol _printf
    hlt ; hlt ; hlt ; hlt ; hlt
    .subsections_via_symbols

Интересующая вас часть начинается прямо перед лейблом L3.