Liuw's Thinkpad

本文从Inline assembly for x86 in Linux中摘译。

movl %eax, %ebx -- transfers the contents of eax to ebx

movb %al, %bl
movw %ax, %bx
movl %eax, %ebx

movl $0xffff, %eax

movb (%esi), %al -- will transfer the byte in the memory pointed by esi to al

asm ( assembler template
    : output operands
    : input operands
    : list of clobbered registers
    );

asm ("movl %%cr4, %0\n" :"=r"(cr3val))

a    %eax
b    %ebx
c    %ecx
d    %edx
S    %esi
D    %edi

asm ("sidt %0\n" : :"m"(loc));

asm ("incl %0" :"=a"(var):"0"(var));

int main(void)
{
        int x = 10, y;

        asm ("movl %1, %%eax;"
             "movl %%eax, %0;"
             :"=r"(y) /* y is output operand */
             :"r"(x)  /* x is input operand */
             :"%eax");/* eax is clobbered register */
        return 0;
}

main:
        pushl %ebp
        movl %esp, %ebp
        subl $8, %esp
        movl $10, -4(%ebp)
        movl -4(%ebp), %edx /* x=10 is stored in %edx */
,#APP
        movl %edx, %eax /* x is moved to eax */
        movl %eax, %edx /* y is allocated in edx and updated */
,#NO_APP
        movl %edx, -8(%ebp) /* value of y in the stack is updated with the value in edx */

int main(void)
{
        int x = 10, y;

        asm ("movl %1, %%eax;"
             "movl %%eax, %0;"
             :"=r"(y) /* y is output operand, note the "&" modifier */
             :"r"(x)  /* x is input operand */
             :"%eax");/* eax is clobbered register */
        return 0;
}

main:
        pushl %ebp
        movl %esp, %ebp
        subl $8, %esp
        movl $10, -4(%ebp)
        movl -4(%ebp), %ecx /* x=10 is stored in %ecx */
,#APP
        movl %ecx, %eax
        movl %eax, %edx /* output is in %edx */
,#NO_APP
        movl %edx, -8(%ebp)

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));

,#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
        : "=a" (__res) \
        : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
          "d" ((long)(arg3)),"S" ((long)(arg4))); \
__syscall_return(type,__res); \
}

__asm__ __volatile__(
        "lock; decl %0"
        :"=m"(counter)
        :"m"(counter));

,#APP
        lock
        decl -24(%ebp)
,#NO_APP

asm ("movl $count, %%ecx;
      up: lodsl;
      stosl;
      loop up;"
     :
     :"S"(src), "D"(dst)
     :"%ecx", "%eax");

换了一台新机器去做TPM硬件驱动的开发，于是从远程仓库把代码clone下来。试着把代码编译一次，出问题了，满版的错误，费点时间看了一下，其实是stddef.h没有找到造成的。

新机器和原来的机器都是一样系统，工具链也是一样的，代码也已经在我原来的机器上编译通过了。用find找了一下stddef.h，在机器上也是有的。仔细对比了一下通过和不通过的CFLAGS，发现不通过的情况下，头文件路径中没有gcc的包含路径，问题就出在这里了。

再看Makefile，gcc路径是通过如下的方法取得的。

GCC_INSTALL = $(shell gcc --print-serarch-dirs | sed -n -e 's/install: \(.*\)/\1/p')

使用sed匹配了以install开头的行。

但是，我现在这个系统的locale是中文的，所以“install”没有出现，取而代之的是“安装”，匹配不成功，GCC_INSTALL就成了空值，那么也没有把路径加入。

追踪了半天，没想到是locale出了问题。因为我原来一直用的是英文系统，所以没有遇到过这种情况。所以以后装系统，最好还是用英文的locale，不是说崇洋媚外不喜欢中文，要是遇到我今天的情况，估计还是挺恶心的，看着满版的错误，挺郁闷的。

“likely()” and “unlikely()” are macros defined in Linux kernel. But the true story is about optimization.

#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

These macros can be used in user space, though. Because they are in fact some built-in features of gcc(1). gcc(1) should optimize assembly generation according to program’s need.

Try this simple sample.

int main()
{
    int a;
    if (likely(a == 100))
        printf("Branch 1\n");
    else
        printf("Branch 2\n");
    return 0;
}

I use an uninitialized variable, that’s a bug, but this does not affect my demostration. Feel free to ignore that uninitialized “a”, we just need something to compare to a constant, don’t we? If I use two constants for comparison, gcc(1) will optimize in compile time and we can not see the outcoming of “likely()” and “unlikely()”.

Use gcc(1) to generate assembly.

$ gcc -S -O2 likely.c

Here is what we get. Ignore less important part, focus on most valuable snippet.

    cmpl $100, %eax
    jne  .L2
    movl $.LC0, (%esp)
    call puts
.L4:
    addl $4, %esp
    xorl %eax, %eax
    popl %ecx
    popl %ebp
    leal -4(%ecx), %esp
    ret
.L2:
    movl $LC1, (%esp)
    call puts
    jmp  .L4

Pay attention to that “jne” directive. We compare variable (which stores in eax) with 100 to see if they are equal. The outcoming result is “likely” to be true, so that “jne” is not executed, the code just falls through. The benifit we get is that no jumping means no pipe line flush, we can make full use of directive cache.

If I change “likely” to “unlikely” in my C code, assembly code generation will be different. However, it should follow the same rule as above – make full use of pipe line.

In linux/kernel.h, there is such a macro

/*
 * min()/max() macros that also do
 * strict type-checking.. See the
 * "unnecessary" pointer comparison.
 */
#define min(x,y) ({ \
        typeof(x) _x = (x); \
        typeof(y) _y = (y); \
        (void) (&_x == &_y); \
        _x < _y ? _x : _y; })

In order to do strict type-checking, that “unnecessary” pointer comparison is, however, necessary. If we compare two distinct pointers without a cast, gcc will complain about it, so that we are able to figure out where things go wild.

To go further, we need some knowledge about Type System, which means “a tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute”. That requires an understanding of computer language theories, which is beyond my knowledge now. I shall figure it out in the future.

http://en.wikipedia.org/wiki/Type_system