Alfred Huang's Weblog

On Studio and Gcc style inline assembly

A question has been raised raised on the optimizaton effect of Sun Studio's inline assembly machanism and that of gcc style enhanced inline assembly. Let's start with a brief introduction of what they are first and then discuss the optimization effect they may have.

At the simplest level, both compilers support the asm() statement, which is the insert-as-is non-optimized inline assembly. This form of inline assembly simply inserts the enclosed assembly string(s) as is without any facility of argument and optimization.

Studio for enhancement supports the .il inline template in a form similar to an include file. A .il file may contain multiple inline templates. Where each template is of the following form:

    .inline "template_name",0
       "assembly code"
    .end

In a sense, Studio treats each inline template as a function definition and adheres argument passing and return value according to the calling convention in the ABI of the corresponding platform.

For example, let's add 8 numbers together and return its result. The inline template in the foo.il file may be as follow:

    .inline multi_add,0
    movq    %rdi, %rax
    movq    %rsi, %rax
    movq    %rdx, %rax
    movq    %rcx, %rax
    movq    %r8,  %rax
    movq    %r9,  %rax
    movq    (%rsp),%rax
    movq    8(%rsp), %rax
    .end

The foo.c file may look like:

    int foo(int,int,int,int,int,int,int,int);
    int multi_add() 
    {
       return foo(1,2,3,4,5,6,7,8);
    }

Compile the foo.c with foo.il:

    cc -S -O -xarch=amd64 foo.il foo.c

The result foo.s will contain an optimized result:

    foo:  ...
    / ASM INLINE BEGIN:   multi_add
          movq   $36, %rax
    / ASM INLINE END

Based on the calling convention of the AMD64 ABI, the first six integral arguments are passed in %rdi, %rsi, %rdx, %rcx, %r8 and %r9, any extras are to be passed on the stack, hence (%rsp) and 8(%rsp) in this case. If optimization is not desired, a -Wu,-no_a2lf option can be used:

    cc -S -O -xarch=amd64 -Wu,-no_a2lf foo.il foo.c

Thus the result foo.s will contain the following:

        push       $8           
        push       $7          
        movq       $1,%rdi     
        movq       $2,%rsi     
        movq       $3,%rdx     
        movq       $4,%rcx     
        movq       $5,%r8      
        movq       $6,%r9                  
        / INLINE: multi_add
        movq    %rdi, %rax
        addq    %rsi, %rax
        addq    %rdx, %rax
        addq    %rcx, %rax
        addq    %r8, %rax
        addq    %r9, %rax
        addq    (%rsp), %rax
        addq    0x8(%rsp), %rax
        / INLINE_END

Studio treats an inline template as a function call, thereby function argument loading will take place before the template body is inserted. If -Wu,-no_a2lf is not used, all these assembly instructions are inserted into Studio's intermediate representation stream and all specified optimization will take place, result in a single "movq $36, %rax".

In this manner, the user specified inline template will be assimilated into the Studio's optimization and code generation machanism. Further note that all registers specified in the inline template will be "virtualized" and reallocated by the code generator, thereby the final appearance of the inline template may be drastically different from its original. The main catch of the approach being users must understand the calling convention of the underlying platform.

Gcc style extended asm inline assembly takes a different approach. Basically it has the form:

    asm("template",
        "input arguments",
        "output arguments",
        "clobber list");

The approach provides flexibility for user to specify the input and output arguments and allows the user to inform the compiler of the resource used within the template, thus allowing the compiler to avoid resource conflict. Other than that, the template is treated as a black box with its content not to be looked into, hence the argument substituted template body will be inserted as is, the optimization effect may then be limited.

For example, let's add 3 constants and a static variable together with the following asm():

int mem;
int foo()
{
        int res;

        asm ("addl %1, %0\n"
             "\taddl %2, %0\n"
             "\taddl %3, %0\n"
             "\taddl %4, %0\n"
             : "=r" (res)
             :  "g" (1),
                "g" (2),
                "g" (3),
                "m" (mem)
            );

        return res;
}

And the result will simply be:

.globl foo
        .type   foo, @function
foo:
/APP
        addl $1, %edx
        addl $2, %edx
        addl $3, %edx
        addl mem, %edx
/NO_APP
        movl    %edx, %eax
        ret

Note the template body will be inserted as is after the argument substitution into the final assembly, no constant fold nor any extensive optimization will be performed. But some forms of optimization may still be performed. For example the entire template may be moved out of a loop if it turns out to be a constant invariant when the "clobber list" indicates no change in memory and register.

Both style of inline assembly machanism has their pros and cons, it depends on one's need and it is possible to convert them from one style to the other.

Posted at 01:40PM May 22, 2006 by alblog in Sun  |  Comments[5]