Walter Bright:

>This is not true of D. In D, the compiler can<

Thank you for your answers.
At the moment D compilers aren't doing this, I think. (LDC performs an 
optimization at link time). But it's nice that D leaves this optimization 
opportunity to future D compilers.

----------------------

If you have noticed that Html page lists three optimizations. The first one is 
the one you have explained.

The second optmizations it talks about is custom calling conventions:

>Normally, all functions are either cdecl, stdcall, or fastcall. With custom 
>calling conventions, the back end has enough knowledge that it can pass more 
>values in registers, and less on the stack. This usually cuts code size and 
>improves performance.<


I have translated his demo code to D:

int foo(int i, int* j, int* k, int l) {
    *j = *k;
    *k = i + l;
    return i + *j + *k + l;
}
int main(char[][] args) {
    int i, j, k, l;
    l = i = args.length;
    int x = foo(i, &j, &k, l);
    return x * args.length;
}


This is how dmd compiles foo() (-O -release):

_D7stdcall3fooFiPiPiiZi comdat
                push    EAX
                mov     ECX,8[ESP]
                mov     EDX,[ECX]
                push    EBX
                mov     EBX,010h[ESP]
                push    ESI
                mov     ESI,018h[ESP]
                push    EDI
                lea     EDI,[EAX][ESI]
                mov     [EBX],EDX
                mov     [ECX],EDI
                mov     EAX,[EBX]
                add     EAX,ESI
                add     EAX,EDI
                add     EAX,0Ch[ESP]
                pop     EDI
                pop     ESI
                pop     EBX
                pop     ECX
                ret     0Ch


This is how LDC compiles foo() with -O3 -release:

_D4test3fooFiPiPiiZi:
    pushl   %esi
    movl    8(%esp), %ecx
    movl    (%ecx), %edx
    movl    12(%esp), %esi
    movl    %edx, (%esi)
    addl    16(%esp), %eax
    movl    %eax, (%ecx)
    addl    %eax, %eax
    addl    (%esi), %eax
    popl    %esi
    ret $12


This is the asm of foo() shown in that article:

_foo:
    mov         ecx,dword ptr [eax]
    mov         dword ptr [esi],ecx
    lea         ecx,[edi+edx]
    mov         dword ptr [eax],ecx
    mov         eax,dword ptr [esi]    // *j
    add         eax,ecx                // *k sub-expression (from
    add         eax,edi                // l
    add         eax,edx                // i
    ret

It seems LDC isn't performing this optimization.

----------------------

The third optimizations it talks about is 'Small TLS Encoding':

>When you use __declspec(thread) variables, the code generator stores the 
>variables at a fixed offset in each per-thread data area. Without LTCG, the 
>code generator has no idea of how many __declspec(thread) variables there will 
>be. As such, it must generate code that assumes the worst, and uses a 
>four-byte offset to access the variable. With LTCG, the code generator has the 
>opportunity to examine all __declspec(thread) variables, and note how often 
>they're used. The code generator can put the smaller, more frequently used 
>variables at the beginning of the per-thread data area and use a one-byte 
>offset to access them.<

This is the C++ example code he uses:

__declspec(thread) int i = 1;
int main() {
    i = 4;
    return i;
}


The asm he shows without this optimization:
_main:
    mov         eax,dword ptr [__tls_index]
    mov         ecx,dword ptr fs:[2Ch]
    mov         ecx,dword ptr [ecx+eax*4]
    push        4
    pop         eax
    mov         dword ptr [ecx+4],eax
    ret



The asm he shows with this optimization:
_main:
    mov         eax,dword ptr fs:[0000002Ch]
    mov         ecx,dword ptr [eax]
    mov         eax,4
    mov         dword ptr [ecx+8],eax
    ret


I have translated that last C++ example in this D code:

int i = 1;
int main() {
    i = 4;
    return i;
}


I think I can't test this with LDC because it doesn't have TLS/__gshared.
dmd compiles it to:

__Dmain
                mov     ECX,FS:__tls_array
                mov     EDX,[ECX]
                mov     EAX,4
                mov     _D4test1ii[EDX],EAX
                ret


On this little example dmd seems to produce similar asm.

Bye,
bearophile

Reply via email to