Changeset 469

Show
Ignore:
Timestamp:
01/01/11 18:10:37 (1 year ago)
Author:
braddr
Message:

Integrate changes from the d1 branch.
Enable the now-working rt/trace and rt/aApplyR unit tests for 64 bit.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/posix.mak

    r464 r469  
    402402    core/sync/rwmutex \ 
    403403    core/sync/semaphore \ 
    404     rt/aApplyR \ 
    405404    rt/adi \ 
    406     rt/dmain2 \ 
    407     rt/trace 
     405    rt/dmain2 
    408406else 
    409407DISABLED_TESTS = \ 
  • trunk/src/rt/alloca.d

    r441 r469  
    146146        add     RAX,15          ; 
    147147        and     AL,0xF0         ; // round up to 16 byte boundary 
     148        test    RAX,RAX         ; 
    148149        jnz     Abegin          ; 
    149150        mov     RAX,16          ; // allow zero bytes allocation 
  • trunk/src/rt/trace.d

    r441 r469  
    175175        uint u; 
    176176 
    177         //printf("\t%.*s\t%u\n", s.Sident, count); 
    178         fprintf(fpdef,"\t%.*s\n", s.Sident); 
     177        //printf("\t%.*s\t%u\n", s.Sident.length, s.Sident.ptr, count); 
     178        fprintf(fpdef,"\t%.*s\n", s.Sident.length, s.Sident.ptr); 
    179179        s.Sflags |= SFvisited; 
    180180 
     
    200200 
    201201        //for (u = 0; u < num; u++) 
    202             //printf("\t\t%.*s\t%u\n", base[u].sym.Sident, base[u].count); 
     202            //printf("\t\t%.*s\t%u\n", base[u].sym.Sident.length, base[u].sym.Sident.ptr, base[u].count); 
    203203 
    204204        // Place symbols 
     
    254254        for (sp = s.Sfanin; sp; sp = sp.next) 
    255255        { 
    256             fprintf(fplog,"\t%5d\t%.*s\n", sp.count, sp.sym.Sident); 
     256            fprintf(fplog,"\t%5d\t%.*s\n", sp.count, sp.sym.Sident.length, sp.sym.Sident.ptr); 
    257257            count += sp.count; 
    258258        } 
    259         fprintf(fplog,"%.*s\t%u\t%lld\t%lld\n",s.Sident,count,s.totaltime,s.functime); 
     259        fprintf(fplog,"%.*s\t%u\t%lld\t%lld\n", s.Sident.length, s.Sident.ptr, count, s.totaltime, s.functime); 
    260260        for (sp = s.Sfanout; sp; sp = sp.next) 
    261261        { 
    262             fprintf(fplog,"\t%5d\t%.*s\n",sp.count,sp.sym.Sident); 
     262            fprintf(fplog,"\t%5d\t%.*s\n", sp.count, sp.sym.Sident.length, sp.sym.Sident.ptr); 
    263263        } 
    264264        s = s.Sr; 
     
    342342 
    343343        fprintf(fplog,"%7d%12lld%12lld%12lld     %.*s\n", 
    344                       calls,tl,fl,pl,id); 
     344                      calls, tl, fl, pl, id.length, id.ptr); 
    345345    } 
    346346} 
     
    764764     */ 
    765765 
    766   version (OSX) 
    767   { // 16 byte align stack 
    768     asm 
    769     {   naked                           ; 
    770         pushad                          ; 
    771         mov     ECX,8*4[ESP]            ; 
    772         xor     EAX,EAX                 ; 
    773         mov     AL,[ECX]                ; 
    774         cmp     AL,0xFF                 ; 
    775         jne     L1                      ; 
    776         cmp     byte ptr 1[ECX],0       ; 
    777         jne     L1                      ; 
    778         mov     AX,2[ECX]               ; 
    779         add     8*4[ESP],3              ; 
    780         add     ECX,3                   ; 
    781     L1: inc     EAX                     ; 
    782         inc     ECX                     ; 
    783         add     8*4[ESP],EAX            ; 
    784         dec     EAX                     ; 
    785         sub     ESP,4                   ; 
    786         push    ECX                     ; 
    787         push    EAX                     ; 
    788         call    trace_pro               ; 
    789         add     ESP,12                  ; 
    790         popad                           ; 
    791         ret                             ; 
    792     } 
    793   } 
    794   else 
    795   { 
    796     asm 
    797     {   naked                           ; 
    798         pushad                          ; 
    799         mov     ECX,8*4[ESP]            ; 
    800         xor     EAX,EAX                 ; 
    801         mov     AL,[ECX]                ; 
    802         cmp     AL,0xFF                 ; 
    803         jne     L1                      ; 
    804         cmp     byte ptr 1[ECX],0       ; 
    805         jne     L1                      ; 
    806         mov     AX,2[ECX]               ; 
    807         add     8*4[ESP],3              ; 
    808         add     ECX,3                   ; 
    809     L1: inc     EAX                     ; 
    810         inc     ECX                     ; 
    811         add     8*4[ESP],EAX            ; 
    812         dec     EAX                     ; 
    813         push    ECX                     ; 
    814         push    EAX                     ; 
    815         call    trace_pro               ; 
    816         add     ESP,8                   ; 
    817         popad                           ; 
    818         ret                             ; 
    819     } 
    820   } 
     766    version (OSX) 
     767    { 
     768        // 16 byte align stack 
     769        version (D_InlineAsm_X86) 
     770        { 
     771            asm 
     772            { 
     773                naked                           ; 
     774                pushad                          ; 
     775                mov     ECX,8*4[ESP]            ; 
     776                xor     EAX,EAX                 ; 
     777                mov     AL,[ECX]                ; 
     778                cmp     AL,0xFF                 ; 
     779                jne     L1                      ; 
     780                cmp     byte ptr 1[ECX],0       ; 
     781                jne     L1                      ; 
     782                mov     AX,2[ECX]               ; 
     783                add     8*4[ESP],3              ; 
     784                add     ECX,3                   ; 
     785            L1: inc     EAX                     ; 
     786                inc     ECX                     ; 
     787                add     8*4[ESP],EAX            ; 
     788                dec     EAX                     ; 
     789                sub     ESP,4                   ; 
     790                push    ECX                     ; 
     791                push    EAX                     ; 
     792                call    trace_pro               ; 
     793                add     ESP,12                  ; 
     794                popad                           ; 
     795                ret                             ; 
     796            } 
     797        } 
     798        else version (D_InlineAsm_X86_64) 
     799            static assert(0); 
     800        else 
     801            static assert(0); 
     802    } 
     803    else 
     804    { 
     805        version (D_InlineAsm_X86) 
     806        { 
     807            asm 
     808            { 
     809                naked                           ; 
     810                pushad                          ; 
     811                mov     ECX,8*4[ESP]            ; 
     812                xor     EAX,EAX                 ; 
     813                mov     AL,[ECX]                ; 
     814                cmp     AL,0xFF                 ; 
     815                jne     L1                      ; 
     816                cmp     byte ptr 1[ECX],0       ; 
     817                jne     L1                      ; 
     818                mov     AX,2[ECX]               ; 
     819                add     8*4[ESP],3              ; 
     820                add     ECX,3                   ; 
     821            L1: inc     EAX                     ; 
     822                inc     ECX                     ; 
     823                add     8*4[ESP],EAX            ; 
     824                dec     EAX                     ; 
     825                push    ECX                     ; 
     826                push    EAX                     ; 
     827                call    trace_pro               ; 
     828                add     ESP,8                   ; 
     829                popad                           ; 
     830                ret                             ; 
     831            } 
     832        } 
     833        else version (D_InlineAsm_X86_64) 
     834        { 
     835            asm 
     836            { 
     837                naked                           ; 
     838                push    RAX                     ; 
     839                push    RCX                     ; 
     840                push    RDX                     ; 
     841                push    RSI                     ; 
     842                push    RDI                     ; 
     843                push    R8                      ; 
     844                push    R9                      ; 
     845                push    R10                     ; 
     846                push    R11                     ; 
     847                mov     RCX,9*8[RSP]            ; 
     848                xor     RAX,RAX                 ; 
     849                mov     AL,[RCX]                ; 
     850                cmp     AL,0xFF                 ; 
     851                jne     L1                      ; 
     852                cmp     byte ptr 1[RCX],0       ; 
     853                jne     L1                      ; 
     854                mov     AX,2[RCX]               ; 
     855                add     9*8[RSP],3              ; 
     856                add     RCX,3                   ; 
     857            L1: inc     RAX                     ; 
     858                inc     RCX                     ; 
     859                add     9*8[RSP],RAX            ; 
     860                dec     RAX                     ; 
     861                push    RCX                     ; 
     862                push    RAX                     ; 
     863                call    trace_pro               ; 
     864                add     RSP,16                  ; 
     865                pop     R11                     ; 
     866                pop     R10                     ; 
     867                pop     R8                      ; 
     868                pop     R9                      ; 
     869                pop     RDI                     ; 
     870                pop     RSI                     ; 
     871                pop     RDX                     ; 
     872                pop     RCX                     ; 
     873                pop     RAX                     ; 
     874                ret                             ; 
     875            } 
     876        } 
     877        else 
     878            static assert(0); 
     879    } 
    821880} 
    822881 
     
    827886void _trace_epi_n() 
    828887{ 
    829   version (OSX) 
    830   { // 16 byte align stack 
    831     asm 
    832     {   naked   ; 
    833         pushad  ; 
    834         sub     ESP,12  ; 
    835     } 
    836     trace_epi(); 
    837     asm 
    838     { 
    839         add     ESP,12  ; 
    840         popad   ; 
    841         ret     ; 
    842     } 
    843   } 
    844   else 
    845   { 
    846     asm 
    847     {   naked   ; 
    848         pushad  ; 
    849     } 
    850     trace_epi(); 
    851     asm 
    852     { 
    853         popad   ; 
    854         ret     ; 
    855     } 
    856   } 
    857 
    858  
    859  
    860 version (Windows) 
     888    version (OSX) 
     889    { // 16 byte align stack 
     890        version (D_InlineAsm_X86) 
     891        { 
     892            asm 
     893            { 
     894                naked           ; 
     895                pushad          ; 
     896                sub     ESP,12  ; 
     897            } 
     898            trace_epi(); 
     899            asm 
     900            { 
     901                add     ESP,12  ; 
     902                popad           ; 
     903                ret             ; 
     904            } 
     905        } 
     906        else version (D_InlineAsm_X86_64) 
     907            static assert(0); 
     908        else 
     909            static assert(0); 
     910    } 
     911    else 
     912    { 
     913        version (D_InlineAsm_X86) 
     914        { 
     915            asm 
     916            { 
     917                naked           ; 
     918                pushad          ; 
     919            } 
     920            trace_epi(); 
     921            asm 
     922            { 
     923                popad           ; 
     924                ret             ; 
     925            } 
     926        } 
     927        else version (D_InlineAsm_X86_64) 
     928        { 
     929            asm 
     930            { 
     931                naked           ; 
     932                push    RAX     ; 
     933                push    RDX     ; 
     934            } 
     935            trace_epi(); 
     936            asm 
     937            { 
     938                pop     RDX     ; 
     939                pop     RAX     ; 
     940                ret             ; 
     941            } 
     942        } 
     943        else 
     944            static assert(0); 
     945    } 
     946
     947 
     948 
     949version (Win32) 
    861950{ 
    862951    extern (Windows) 
     
    866955    } 
    867956} 
    868 else version (X86) 
     957else version (D_InlineAsm_X86) 
    869958{ 
    870959    extern (D) 
     
    873962        { 
    874963            asm 
    875             {   naked                   ; 
     964            { 
     965                naked                   ; 
    876966                mov       ECX,EAX       ; 
    877967                rdtsc                   ; 
     
    888978    } 
    889979} 
    890 else version (X86_64) 
     980else version (D_InlineAsm_X86_64) 
    891981{ 
    892982    extern (D) 
     
    895985        { 
    896986            asm 
    897             {   naked                   ; 
     987            { 
     988                naked                   ; 
    898989                rdtsc                   ; 
    899990                mov   [RDI],EAX         ;