Notes of Inline Assembly

Notes of Inline Assembly

Table of Contents

1 The syntax comparation of Intel ASM and AT&T ASM
2 Basic inline assembly

2.1 'asm'
2.2 '__asm__'
2.3 '__asm__ __volatile__'

3 Extended inline assembly

3.1 Some examples

1 The syntax comparation of Intel ASM and AT&T ASM

Register Naming For AT&T ASM, register names are prefixed with '%'

1:  - AT&T:  %eax
2:  - Intel:  eax

Source & Destination ordering The source is always at left and the destination is always at right.

1:  - AT&T:  movl %eax, %ebx
2:  - Intel: mov ebx, eax

Constant value or immediate value format Should be prefixed with '$' The below example is to set 'eax' to '3'

1:  - AT&T:  movl $0x3, %eax
2:  - Intel: mov eax, 0x3

The below example moves 'C' defined variable 'boo' to 'eax'

1:  - AT&T:  movl $_boo, %eax
2:  - Intel: mov eax, _boo

Operator size specification You must suffix you instruction with one of 'b', 'w', 'l' to specify your destination register width as a 'byte', 'word' or 'longword'. Otherwise, the GNU assembler will guess.

1:  - AT&T:   movw %ax, %bx
2:  - Intel:  mov bx, ax

Referencing memory C language: immd32[base + index * scale]

1:  - AT&T: immd32(base, index, scale)
2:  - Intel: [base + index * scale + immd32]
3:    + Address particular C variable
4:      - AT&T:   (_boo)
5:      - Intel:  [_boo]
6:    + Address what register point to
7:      - AT&T:   (%eax)
8:      - Intel:  [eax]
9:    + Address a variable offeset by the value of a register
10:      - AT&T:   _foo(%eax)
11:      - Intel:  [eax + _foo]
12:    + Address a value in a array of integer
13:      - AT&T:   _array(,%eax,4)
14:      - Intel:  [eax * 4 + _array]

2 Basic inline assembly

2.1 'asm'

The basic inline assembly is very simple

asm("statements");

For exmaple:

asm("nop");
asm("movl %eax, %ebx");

1:  asm ("pushl %eax\n\t"
2:       "movl $0, %eax\n\t"
3:       "popl %eax");

2.2 '__asm__'

If 'asm' conficts with something keywords in your program, you could use

1:  __asm__("statements");

2.3 '__asm__ __volatile__'

If you don't want your assembly to be optimized by assembler, add volatile keyword.

3 Extended inline assembly

The extended assembly allows input arguments and output arguments. The basic

format is as below:

1:  Format:
2:      asm ("statements : output_registers : input_registers : clobbered_registers")
3:      For the clobbered_reisters, it means that you cannot count on these registers.
4:      Their values may change.
5:  Example:
6:      asm ("cld\n\t"
7:           "rep\n\t"
8:           "stosl"
9:           : /* no output registers */
10:           : "c" (count), "a" (fill_value), "D" (dest)
11:           : "%ecx", "%edi" );

The list of register loading code which could be used.

a	eax
b	ebx
c	ecx
d	edx
S	esi
D	edi
I	constant value (0 to 31)
q,r	dynamically allocated register (see below)
g	eax, ebx, ecx, edx or variable in memory
A	eax and edx combined into a 64-bit integer (use long longs)

The differences between 'q' and 'r' in the table

'q' makes GCC to allocate 'eax', 'ebx', 'ecx' and 'edx'
'r' makes GCC also consider 'esi' and 'edi'

3.1 Some examples

1:  // Disable interrupt
2:  #define disable() __asm__ __volatile__ ("cli");
3:
4:  // Enable interrupt
5:  #define enable() __asm__ __volatile__ ("sti");
6:
7:  // arg2 = arg1 + arg1 * 4;
8:  #define times5(arg1, arg2) \
9:  __asm__ ( \
10:    "leal (%0,%0,4),%0" \
11:    : "=r" (arg2) \
12:    : "0" (arg1) );
13:
14:  // arg2 = arg1 + arg1 * 8;
15:  #define times9(arg1, arg2) \
16:  __asm__ ( \
17:    "leal (%0,%0,8),%0" \
18:    : "=r" (arg2) \
19:    : "0" (arg1) );
20:

For the {%n}, it is straightforward first-come-first-serve, left-to-right thing, mapping to 'q' and 'r'.
So it will be "0", "1", "2" … etc

1:  asm ("leal (%%ebx,%%ebx,4), %%ebx"
2:       : "=b" (x)
3:       : "b" (x) );

If you want to use reigters in extended assemly, you should prefix the register with "%%" not just "%".