GCC ARM Сборка препроцессора Макро - PullRequest
Новая
       44

GCC ARM Сборка препроцессора Макро

5 голосов
/ 25 мая 2011

Я пытаюсь использовать макрос сборки (ARM) для умножения с фиксированной запятой: 

    #define MULT(a,b) __asm__ __volatile__ ( \
        "SMULL r2, r3, %0, %1\n\t" \
        "ADD r2, r2, #0x8000\n\t" \
        "ADC r3, r3, #0\n\t" \
        "MOV %0, r2, ASR#16\n\t" \
        "ORR %0, %0, r3, ASL#16" \
        : "=r" (a) : "0"(a), "1"(b) : "r2", "r3" );

но при попытке компиляции я получаю сообщение об ошибке: ожидаемое выражение перед ' asm '

(Вы можете игнорировать все, что ниже этого, если цените свое время, но было бы неплохо, если бы вы посмотрели на него, основной вопрос здесь заключается в том, как заставить вышеуказанное работать)

Я пробовал это: 

    static inline GLfixed MULT(GLfixed a, GLfixed b){
       asm volatile(
        "SMULL r2, r3, %[a], %[b]\n"
        "ADD r2, r2, #0x8000\n"
        "ADC r3, r3, #0\n"
        "MOV %[a], r2, ASR#16\n"
        "ORR %[a], %[a], r3, ASL#16\n"
        : "=r" (a)
        : [a] "r" (a), [b] "r" (b)
        : "r2", "r3");
     return a; }

Это компилируется, но, похоже, есть проблема, потому что когда я использую константы ex: MULT (65536,65536), это работает, но когда я использую переменные, кажется, что f ** k up: 

GLfixed m[16];
m[0]=costab[player_ry];//1(65536 integer representation)
m[5]=costab[player_rx];//1(65536 integer representation)
m[6]=-sintab[player_rx];//0
m[8]=-sintab[player_ry];//0
LOG("%i,%i,%i",m[6],m[8],MULT(m[6],m[8]));
m[1]=MULT(m[6],m[8]);
m[2]=MULT(m[5],-m[8]);
m[9]=MULT(-m[6],m[0]);
m[10]=MULT(m[5],m[0]);
m[12]=MULT(m[0],0)+MULT(m[8],0);
m[13]=MULT(m[1],0)+MULT(m[5],0)+MULT(m[9],0);
m[14]=MULT(m[2],0)+MULT(m[6],0)+MULT(m[10],0);
m[15]=0x00010000;//1(65536 integer representation)

int i=0;
while(i<16)
{
    LOG("%i,%i,%i,%i",m[i],m[i+1],m[i+2],m[i+3]);
    i+=4;
}

Приведенный выше код будет напечатан (LOG здесь как printf): 

0,0,-1411346156
65536,65536,65536,440
-2134820096,65536,0,-1345274311
0,65536,22,220
65536,196608,131072,65536

Когда правильный результат будет (очевидно, много мусора в приведенном выше): 

0,0,0
65536,0,0,0
0,65536,0,0
0,0,65536,0
0,0,0,65536

Ответы [ 2 ]

5 голосов
/ 25 мая 2011

Первая часть достаточно проста: проблема в том, что блок __asm__ является оператором, а не выражением.

Вы можете использовать выражения выражения GCC , чтобы достичь того, что выхочу - как-то так: 

#define MULT(a,b) \
  ({ \
    __asm__ __volatile__ ( \
      /* ... asm stuff here ... */
    ); \
    a; \
  })

Вторая часть связана с проблемами в спецификациях операнда ввода и вывода.У вас есть две разные версии, и обе не правы.В макро-версии вы сказали: 

: "=r" (a) : "0"(a), "1"(b) : "r2", "r3"

, который ограничивает

  • вывод a в регистр (это операнд 0);
  • вход a должен быть таким же, как операнд 0, т. е. тот же регистр (это операнд 1);
  • вход b должен быть таким же, как операнд 1, т.е.является операндом 2).

Вам нужно "r"(b) здесь, и оно может называться %2.

В встроенной версии вы сказали: 

: "=r" (a) : [a] "r" (a), [b] "r" (b) : "r2", "r3"

, который ограничивает выходные данные a и входные данные a и b для регистров, но

  • не объявляет никакой связи между ними;
  • asm никогда не ссылается явно на выходной операнд (вы не дали выходному операнду имя, а код asm не ссылается на %0).

Вы должны иметь возможностьисправьте исходную версию с помощью: 

: "=r" (a) : "0" (a), "r" (b) : "r2", "r3"

и обозначьте a как %0 или %1, а b как %2.

Встроенная версияможно исправить лВот так: 

: [a] "=r" (a) : "[a]" (a), [b] "r" (b) : "r2", "r3"

и операнды обозначаются как %[a] и %[b].

Если вы хотите использовать имена в макропрограмме, вам понадобится что-то вроде строки

: [arg_a] "=r" (a) : "[arg_a]" (a), [arg_b] "r" (b) : "r2", "r3"

(и обратитесь к %[arg_a] и %[arg_b]), потому что в противном случае препроцессор расширит a и b внутри [a] и [b].

Обратите внимание на тонкость в случаях именованных аргументов: когда имя дается аргументу (как в выводе a), вы пишете [a] - без кавычек - но когда вы ссылаетесь на имя другого уже названногооперанд (как во входных данных a) вы должны поместить его в кавычки: "[a]".

3 голосов
/ 25 мая 2011

Вы пробовали простой C-код вместо сборки?В моей системе с GCC 4.5.3 компилятор генерирует код, который по крайней мере так же хорош, как ваш рукописный ассемблер: 

int mul (int a, int b)
{
  long long x = ((long long)a * b + 0x8000);
  return x>>16;
}

компилируется в следующий asm-код: 

# input: r0, r1
mov    r3, #32768
mov    r4, #0
smlal  r3, r4, r0, r1
mov    r0, r3, lsr #16
orr    r0, r0, r4, asl #16
# result in r0

(Удален эпилог вызова функции и пролог)

Код становится еще лучше, если у вас есть несколько умножений в одной функции, потому что компилятор удалит избыточные инструкции mov r3, # 32768.

...