Inline asm for x86

                                       
    Colin Plumb (colin@nyx.net)
    Mon, 20 Apr 1998 18:56:24 -0600 (MDT)
    colin@nyx.net, 20 April 1998
 

Краткое руководство GCC inline asm

Рассматривается один из инструментов ускорения работы ядра - расширенный ассемблер.

Рассмотрим пример :

   asm("foo %1,%2,%0" : "=r" (output) : "r" (input1), "r" (input2));
 

   asm("foo %1,%2,%0" : "=r" (ptr->vtable[3](a,b,c)->foo.bar[baz]) :
       : "r" (gcc(is) + really(damn->cool)), "r" (42));
 

 register int t0, t1, t2;
   t1 = gcc(is) + really(damn->cool);
   t2 = 42;
   asm("foo %1,%2,%0" : "=r" (t0) : "r" (t1), "r" (t2));
   ptr->vtable[3](a,b,c)->foo.bar[baz] = t0;
 

   asm( "code" : outputs : inputs : clobbers);
 

Как output , так и input состоят из 2-х частей - "constraints" и (value). Для outputs (value) - возвращаемое значение.

outputs должен быть промаркирован знаком равенства "=".

"r" - или "rm" - буквально - register or memory. "ri" - register или immediate value. "g" - "general" - может быть и тем и другим. "o" похоже на "m" - "offsettable", означающее , что вы можете прибавить к нему смещение. Для x86 все операнды в памти - offsettable, поддерживающее индексацию.

* Несколько слов о inputs

input может быть временной переменной.

GCC может разместить output в том же регистре, в котором приходит input ,если последний более не нужен.

* x86 assembly code

GNU использует AT&T-синтаксис,который отличается от Intel-синтаксиса. В AT&T например отсутствует DWORD PTR . Intel использует "op dest,src", AT&T использует "op src,dest".

AT&T использует знак процента для обозначения регистров - %eax, %ebx. Не нужно ставить символ подчеркивания перед переменными и именами функций.

Отличие также в том , что в AT&T размер операнда зашит в саму инструкцию - например , вместо inc нужно - "incb", "incw" ,"incl" соответственно для 8, 16 или 32 бит. Иногда размер операнда указывать необязательно - например можно написать "inc %eax" - и так понятно,что речь идет о 2-х байтах. Но если вы работаете с операндами в памяти , нужно писать"incl foo", а не "inc foo",иначе будет ошибка. "incl %al" - это конечно тоже ошибка.

Перед именем внешней си-шной переменной можно ставить символ доллара - $.
При этом , "movl foo,%eax" копирует содержимое памяти, расположенной по адресу foo , в регистр %eax.
А "movl $foo,%eax" даст совершенно другой эффект - будет скопирован адрес переменной foo.
"movl 42,%eax" - копирование абсолютного значения.

Адресные режимы реализованы с помощью формата offset(base,index,scale). Например , -44(%ebx,%eax) будет эквивалентно -44(%ebx,%eax,1). В качестве шкалы можно использовать 1, 2 ,4 , 8.

* Equivalence constraints

Иногда может возникнуть ситуация,когда для ввода и вывода нужен один и тот же регистр. Для этого можно использовать специальный constraint "0":

   asm("foo %1,%0" : "=r" (output) : "r" (input1), "0" (input2));
 

* Constraints on the x86

i386 имеет достаточно типов регистров для прикладного использования. Основные типы :

 g - general effective address
 m - memory effective address
 r - register
 i - immediate value, 0..0xffffffff
 n - immediate value known at compile time.
 

 q - регистры с байтовой адресацией (eax, ebx, ecx, edx)
 A - eax или edx
 a, b, c, d, S, D - eax, ebx, ecx, edx, esi, edi соответственно
 
 I - immediate 0..31
 J - immediate 0..63
 K - immediate 255
 L - immediate 65535
 M - immediate 0..3 (shifts that can be done with lea)
 N - immediate 0..255 (one-byte immediate value)
 O - immediate 0..32
 

 
   asm("roll %1,%0" : "=g" (result) : "cI" (rotate), "0" (input));
 

* Advanced constraints

= используется для маркировки output.  

% говорит о том , что данный и следующий операнды могут
 обменять свои приоритеты

, разделитель constraints.  
 x86 разрешает операции типа register-memory и  memory-register , 
 но запрещает memory-memory:

     asm("add %1,%0" : "=r,rm" (output) : "%g,ri" (input1), "0,0" (input2));
 

& output operand пишется перед inputs , поэтому output и input 
 должны быть в разных регистрах.

* const and volatile

Есть 2 хинта , которые можно применить к asm- выражениям.

asm volatile(...) - ключевое слово volatile говорит компилятору , что он не может его оптимизировать и обязан выполнять именно так , как оно записано.

asm const() - может быть оптимизировано как обычное subexpression optimization.

 Пример:
   int foo(int x);
   {
     int i, y, total;
 
     total = 0;
     for (i = 0; i < 100; i++) {
       asm volatile("foo %1,%0" : "=r" (y) : "g" (x));
       total += y;
     }
     return total;
   }
 

 func1:
         xorl %ecx,%ecx
         pushl %ebx
         movl %ecx,%edx
         movl 8(%esp),%ebx
         .align 4
 .L7:
 #APP
         foo %ebx,%eax
 #NO_APP
         addl %eax,%ecx
         incl %edx
         cmpl $99,%edx
         jle .L7
         movl %ecx,%eax
         popl %ebx
         ret
 >

 func2:
         xorl %edx,%edx
 #APP
         foo 4(%esp),%ecx
 #NO_APP
         movl %edx,%eax
         .align 4
 .L13:
         addl %ecx,%edx
         incl %eax
         cmpl $99,%eax
         jle .L13
         movl %edx,%eax
         ret
 

* Alternate keywords

* Output substitutions

   asm("lea %1(%2,%3,1<<%4),%0" : "=r" (out)
       : "%i" (in1), "r" (in2), "r" (in3), "M" (logscale));
 

         lea $-44(%ebx,%eax,1<<$2),%ecx
 

   asm("lea %c1(%2,%3,1<<%c4),%0" : "=r" (out)
       : "%i" (in1), "r" (in2), "r" (in3), "M" (logscale));
 

         lea -44(%ebx,%eax,1<<2),%ecx
 
 Еще один символ-модификатор - n
 %n0 работает аналогично %c0, но делает значение отрицательным
 %l0 аналогично %c0, для jump target.
 
 %k0 выводит  32-битную форму операнда.  %eax, etc.
 %w0 выводит  16-битную форму операнда.  %ax, etc.
 %b0 выводит  8-битную форму операнда.  %al, etc.
 %h0 выводит старшие  8 бит регистра.  %ah, etc.
 %z0 выводит opcode операнда, b, w или l.
 

asm("inc %0" : "=r" (out) : "0" (in))

выведет "inc %al", "inc %ax" или "inc %eax" в зависимости от типа "out".

Можно использовать %w и %b для обьектов не-регистрового типа. Рассмотрим пример:

   #define xchg(m, in, out)      \
     asm("xchg%z0 %2,%0" : "=g" (*(m)), "=r" (out) : "1" (in))
 
   int
   bar(void *m, int x)
   {
     xchg((char *)m, (char)x, x);
     xchg((short *)m, (short)x, x);
     xchg((int *)m, (int)x, x);
     return x;
   }
 

 
 .globl bar
         .type    bar,@function
 bar:
         movl 4(%esp),%eax
         movb 8(%esp),%dl
 #APP
         xchgb %dl,(%eax)
         xchgw %dx,(%eax)
         xchgl %edx,(%eax)
 #NO_APP
         movl %edx,%eax
         ret
 

* Extra % patterns

Еще одним примером является %=, генерирующий уникальное число для asm()-блока. Это может быть использовано для меток-шаблонов.

* Examples

 
 #define _set_tssldt_desc(n,addr,limit,type) \
 __asm__ __volatile__ ("movw %3,0(%2)\n\t" \
         "movw %%ax,2(%2)\n\t" \
         "rorl $16,%%eax\n\t" \
         "movb %%al,4(%2)\n\t" \
         "movb %4,5(%2)\n\t" \
         "movb $0,6(%2)\n\t" \
         "movb %%ah,7(%2)\n\t" \
         "rorl $16,%%eax" \
         : "=m"(*(n)) : "a" (addr), "r"(n), "ri"(limit), "i"(type))
 

 #define _set_tssldt_desc(n,addr,limit,type) \
 __asm__ __volatile__ ("movw %w3,0(%2)\n\t" \
         "movw %w1,2(%2)\n\t" \
         "rorl $16,%1\n\t" \
         "movb %b1,4(%2)\n\t" \
         "movb %4,5(%2)\n\t" \
         "movb $0,6(%2)\n\t" \
         "movb %h1,7(%2)\n\t" \
         "rorl $16,%1" \
         : "=m"(*(n)) : "q" (addr), "r"(n), "ri"(limit), "ri"(type))
 

Пример:

 #define _set_tssldt_desc(n,addr,limit,type) \
 __asm__ __volatile__ ("movw %w2,%0\n\t" \
         "movw %w1,2+%0\n\t" \
         "rorl $16,%1\n\t" \
         "movb %b1,4+%0\n\t" \
         "movb %3,5+%0\n\t" \
         "movb $0,6+%0\n\t" \
         "movb %h1,7+%0\n\t" \
         "rorl $16,%1" \
         : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
 

Пример:

 __asm__ __volatile__ ("movw %w7,%0\n\t" \
         "movw %w6,%1\n\t" \
         "rorl $16,%6\n\t" \
         "movb %b6,%2\n\t" \
         "movb %b8,%3\n\t" \
         "movb $0,%4\n\t" \
         "movb %h6,%5\n\t" \
         "rorl $16,%6" \
         : "=m"(*(n)), \
           "=m"((n)[2]), \
           "=m"((n)[4]), \
           "=m"((n)[5]), \
           "=m"((n)[6]), \
           "=m"((n)[7]) \
        : "q" (addr), "g"(limit), "iqm"(type))
 

Пример

 {
         int a=10, b;
         asm ("movl %1, %%eax;
               movl %%eax, %0;"
                 :"=r"(b)        /* output */
                 :"r"(a)         /* input */
                 :"%eax");       /* clobbered register */
 }
 

      * "b" - output operand, ссылка на %0 , и "a" - input operand, ссылка на %1.
      * "r" - constraint , указывает на то , что переменные  "a" и "b" 
        хранятся в регистрах.
      * Регистр %eax идет с двойным префиксом %
      * clobbered register %eax говорит GCC о том , что значение %eax модифицируется
        внутри"asm", поэтому GCC не использует этот регистр для хранения
        чего-то еще
      * movl %1, %%eax - копируем "a" в %eax, и movl %%eax, %0 -копируем
         %eax в "b".
      * после выполнения "asm" изменеие "b" внутри блока становится
        видно снаружи , потому что b определено как output-операнд	
 

Пример

    
     asm ("cpuid"
                 : "=a" (_eax),
                   "=b" (_ebx),
                   "=c" (_ecx),
                   "=d" (_edx)
                 : "a" (op));
 

    
     movl -20(%ebp),%eax /* store 'op' in %eax -- input */
 #APP
         cpuid
 #NO_APP
         movl %eax,-4(%ebp)      /* store %eax in _eax -- output */
         movl %ebx,-8(%ebp)      /* store other registers in
         movl %ecx,-12(%ebp)        respective output variables */
         movl %edx,-16(%ebp)
 

Пример

     asm ("cld\n
               rep\n
               movsb"
               : /* no input */
               :"S"(src), "D"(dst), "c"(count));
 

Пример

         int i = 0;
         __asm__("
           pushl %%eax\n
           movl %0, %%eax\n
           addl $1, %%eax\n
           movl %%eax, %0\n
           popl %%eax"
           :
           : "g" (i)
         );
 

         int i=0, j=1;
         __asm__ __volatile__("
           pushl %%eax\n
           movl %0, %%eax\n
           addl %1, %%eax\n
           movl %%eax, %0\n
           popl %%eax"
           :
           : "g" (i), "g" (j)
         );
           /* i = i + j; */
 

         int i=0;
         __asm__ __volatile__("
           pushl %%eax\n
           movl $1, %%eax\n
           movl %%eax, %0\n
           popl %%eax"
           : "=g" (i)
         );
           /* i=1; */
 

 
         int i=0, j=1, k=0;
         __asm__ __volatile__("
           pushl %%eax\n
           movl %1, %%eax\n
           addl %2, %%eax\n
           movl %%eax, %0\n
           popl %%eax"
           : "=g" (k)
           : "g" (i), "g" (j)
         );
           /* k = i + j; */
 

         int i=0, j=1, k=0;
         __asm__ __volatile__("
           movl %1, %%eax\n
           addl %2, %%eax\n
           movl %%eax, %0"
           : "=g" (k)
           : "g" (i), "g" (j)
           : "ax", "memory"
         );
           /* k = i + j; */
 

         __asm__ __volatile__("
         0:\n
           ...
           jmp 0b\n
           ...
           jmp 1f\n
           ...
         1:\n
           ...
         );
 

Оставьте свой комментарий !
Ваше имя: Комментарий: Оба поля являются обязательными  Автор   Комментарий к данной статье