Download Reference Manual
The Developer's Library for D
About Wiki Forums Source Search Contact

Changeset 3438

Show
Ignore:
Timestamp:
04/17/08 01:00:04 (5 months ago)
Author:
sean
Message:

Changed use of EBX to scratch register EDX to avoid the need to save/restore EBX in function call. This closes #593

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/tango/core/Atomic.d

    r2356 r3438  
    378378                    volatile asm 
    379379                    { 
    380                         mov BL, 42; 
     380                        mov DL, 42; 
    381381                        mov AL, 42; 
    382382                        mov ECX, val; 
    383383                        lock; 
    384                         cmpxchg [ECX], BL; 
     384                        cmpxchg [ECX], DL; 
    385385                    } 
    386386                } 
     
    403403                    volatile asm 
    404404                    { 
    405                         mov BX, 42; 
     405                        mov DX, 42; 
    406406                        mov AX, 42; 
    407407                        mov ECX, val; 
    408408                        lock; 
    409                         cmpxchg [ECX], BX; 
     409                        cmpxchg [ECX], DX; 
    410410                    } 
    411411                } 
     
    429429                    volatile asm 
    430430                    { 
    431                         mov EBX, 42; 
     431                        mov EDX, 42; 
    432432                        mov EAX, 42; 
    433433                        mov ECX, val; 
    434434                        lock; 
    435                         cmpxchg [ECX], EBX; 
     435                        cmpxchg [ECX], EDX; 
    436436                    } 
    437437                } 
     
    526526                    { 
    527527                        mov EAX, val; 
    528                         mov BL, newval; 
     528                        mov DL, newval; 
    529529                        lock; 
    530                         xchg [EAX], BL; 
     530                        xchg [EAX], DL; 
    531531                    } 
    532532                } 
     
    536536                    { 
    537537                        mov EAX, val; 
    538                         mov BL, newval; 
    539                         mov [EAX], BL; 
     538                        mov DL, newval; 
     539                        mov [EAX], DL; 
    540540                    } 
    541541                } 
     
    553553                    { 
    554554                        mov EAX, val; 
    555                         mov BX, newval; 
     555                        mov DX, newval; 
    556556                        lock; 
    557                         xchg [EAX], BX; 
     557                        xchg [EAX], DX; 
    558558                    } 
    559559                } 
     
    563563                    { 
    564564                        mov EAX, val; 
    565                         mov BX, newval; 
    566                         mov [EAX], BX; 
     565                        mov DX, newval; 
     566                        mov [EAX], DX; 
    567567                    } 
    568568                } 
     
    580580                    { 
    581581                        mov EAX, val; 
    582                         mov EBX, newval; 
     582                        mov EDX, newval; 
    583583                        lock; 
    584                         xchg [EAX], EBX; 
     584                        xchg [EAX], EDX; 
    585585                    } 
    586586                } 
     
    590590                    { 
    591591                        mov EAX, val; 
    592                         mov EBX, newval; 
    593                         mov [EAX], EBX; 
     592                        mov EDX, newval; 
     593                        mov [EAX], EDX; 
    594594                    } 
    595595                } 
     
    614614                        { 
    615615                            mov RAX, val; 
    616                             mov RBX, newval; 
     616                            mov RDX, newval; 
    617617                            lock; 
    618                             xchg [RAX], RBX; 
     618                            xchg [RAX], RDX; 
    619619                        } 
    620620                    } 
     
    624624                        { 
    625625                            mov RAX, val; 
    626                             mov RBX, newval; 
    627                             mov [RAX], RBX; 
     626                            mov RDX, newval; 
     627                            mov [RAX], RDX; 
    628628                        } 
    629629                    } 
     
    682682                volatile asm 
    683683                { 
    684                     mov BL, newval; 
     684                    mov DL, newval; 
    685685                    mov AL, equalTo; 
    686686                    mov ECX, val; 
    687687                    lock; // lock always needed to make this op atomic 
    688                     cmpxchg [ECX], BL; 
     688                    cmpxchg [ECX], DL; 
    689689                    setz AL; 
    690690                } 
     
    699699                volatile asm 
    700700                { 
    701                     mov BX, newval; 
     701                    mov DX, newval; 
    702702                    mov AX, equalTo; 
    703703                    mov ECX, val; 
    704704                    lock; // lock always needed to make this op atomic 
    705                     cmpxchg [ECX], BX; 
     705                    cmpxchg [ECX], DX; 
    706706                    setz AL; 
    707707                } 
     
    716716                volatile asm 
    717717                { 
    718                     mov EBX, newval; 
     718                    mov EDX, newval; 
    719719                    mov EAX, equalTo; 
    720720                    mov ECX, val; 
    721721                    lock; // lock always needed to make this op atomic 
    722                     cmpxchg [ECX], EBX; 
     722                    cmpxchg [ECX], EDX; 
    723723                    setz AL; 
    724724                } 
     
    740740                    volatile asm 
    741741                    { 
    742                         mov RBX, newval; 
     742                        mov RDX, newval; 
    743743                        mov RAX, equalTo; 
    744744                        mov RCX, val; 
    745745                        lock; // lock always needed to make this op atomic 
    746                         cmpxchg [RCX], RBX; 
     746                        cmpxchg [RCX], RDX; 
    747747                        setz AL; 
    748748                    } 
     
    757757                    volatile asm 
    758758                    { 
     759                        push EDI; 
     760                        push EBX; 
    759761                        lea EDI, newval; 
    760762                        mov EBX, [EDI]; 
     
    765767                        mov EDI, val; 
    766768                        lock; // lock always needed to make this op atomic 
    767                         cmpxch8b [EDI]; 
     769                        cmpxchg8b [EDI]; 
    768770                        setz AL; 
     771                        pop EBX; 
     772                        pop EDI; 
    769773                    } 
    770774                }