Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 1728

Show
Ignore:
Timestamp:
07/05/10 01:13:33 (14 years ago)
Author:
walter
Message:

start 64 bit assembler

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/phobos-1.x/phobos/internal/alloca.d

    r1701 r1728  
    2020 *      nbytes  number of bytes to allocate 
    2121 *      ECX     address of variable with # of bytes in locals 
    2222 *              This is adjusted upon return to reflect the additional 
    2323 *              size of the stack frame. 
    2424 * Returns: 
    2525 *      EAX     allocated data, null if stack overflows 
    2626 */ 
    2727 
    2828extern (C) void* __alloca(int nbytes) 
    2929{ 
     30  version (D_InlineAsm_X86) 
     31  { 
    3032    asm 
    3133    { 
    3234        naked                   ; 
    3335        mov     EDX,ECX         ; 
    3436        mov     EAX,4[ESP]      ; // get nbytes 
    3537        push    EBX             ; 
    3638        push    EDI             ; 
    3739        push    ESI             ; 
    3840    } 
    3941 
    …… 
    117119    Aoverflow: 
    118120        // Overflowed the stack.  Return null 
    119121        xor     EAX,EAX         ; 
    120122 
    121123    done: 
    122124        pop     ESI             ; 
    123125        pop     EDI             ; 
    124126        pop     EBX             ; 
    125127        ret                     ; 
    126128    } 
     129  } 
     130  else version (D_InlineAsm_X86_64) 
     131    static assert(0); 
     132  else 
     133    static assert(0); 
    127134} 
    128135 
    129136 
    130137 
    131138 
    132139 
    133140 
    134141 
    135142 
    136143 

  • branches/phobos-1.x/phobos/internal/deh2.d

    r1701 r1728  
    141141    } 
    142142    return bp; 
    143143} 
    144144 
    145145/*********************************** 
    146146 * Throw a D object. 
    147147 */ 
    148148 
    149149extern (Windows) void _d_throw(Object *h) 
    150150{ 
    151     uint regebp; 
     151    size_t regebp; 
    152152 
    153153    debug 
    154154    { 
    155155        printf("_d_throw(h = %p, &h = %p)\n", h, &h); 
    156156        printf("\tvptr = %p\n", *cast(void **)h); 
    157157    } 
    158158 
    159     asm 
    160     { 
    161         mov regebp,EBP  ; 
    162     } 
     159    version (D_InlineAsm_X86) 
     160    asm 
     161    { 
     162        mov regebp,EBP  ; 
     163    } 
     164    else version (D_InlineAsm_X86_64) 
     165    asm 
     166    { 
     167        mov regebp,RBP  ; 
     168    } 
     169    else 
     170    static assert(0); 
    163171 
    164172//static uint abc; 
    165173//if (++abc == 2) *(char *)0=0; 
    166174 
    167175//int count = 0; 
    168176    while (1)           // for each function on the stack 
    169177    { 
    170178        DHandlerTable *handler_table; 
    171179        FuncTable *pfunc; 
    172180        DHandlerInfo *phi; 
    …… 
    254262                    pcb = &pci.catch_block[i]; 
    255263 
    256264                    if (_d_isbaseof(ci, pcb.type)) 
    257265                    {   // Matched the catch type, so we've found the handler. 
    258266 
    259267                        // Initialize catch variable 
    260268                        *cast(void **)(regebp + (pcb.bpoffset)) = h; 
    261269 
    262270                        // Jump to catch block. Does not return. 
    263271                        { 
    264                             uint catch_esp; 
     272                            size_t catch_esp; 
    265273                            fp_t catch_addr; 
    266274 
    267275                            catch_addr = cast(fp_t)(pcb.code); 
    268276                            catch_esp = regebp - handler_table.espoffset - fp_t.sizeof; 
    269                             asm 
    270                             { 
    271                                 mov     EAX,catch_esp   ; 
    272                                 mov     ECX,catch_addr  ; 
    273                                 mov     [EAX],ECX       ; 
    274                                 mov     EBP,regebp      ; 
    275                                 mov     ESP,EAX         ; // reset stack 
    276                                 ret                     ; // jump to catch block 
    277                             } 
     277                version (D_InlineAsm_X86) 
     278                asm 
     279                { 
     280                    mov     EAX,catch_esp   ; 
     281                    mov     ECX,catch_addr  ; 
     282                    mov     [EAX],ECX       ; 
     283                    mov     EBP,regebp      ; 
     284                    mov     ESP,EAX         ; // reset stack 
     285                    ret                     ; // jump to catch block 
     286                } 
     287                else version (D_InlineAsm_X86_64) 
     288                asm 
     289                { 
     290                    mov     RAX,catch_esp   ; 
     291                    mov     RCX,catch_addr  ; 
     292                    mov     [RAX],RCX       ; 
     293                    mov     RBP,regebp      ; 
     294                    mov     RSP,RAX         ; // reset stack 
     295                    ret                     ; // jump to catch block 
     296                } 
     297                else 
     298                static assert(0); 
    278299                        } 
    279300                    } 
    280301                } 
    281302            } 
    282303            else if (phi.finally_code) 
    283304            {   // Call finally block 
    284305                // Note that it is unnecessary to adjust the ESP, as the finally block 
    285306                // accesses all items on the stack as relative to EBP. 
    286307 
    287308                void *blockaddr = phi.finally_code; 
    288309 
    289310                version (OSX) 
    290311                { 
    291                     asm 
    292                     { 
    293                         sub     ESP,4           ; 
    294                         push    EBX             ; 
    295                         mov     EBX,blockaddr   ; 
    296                         push    EBP             ; 
    297                         mov     EBP,regebp      ; 
    298                         call    EBX             ; 
    299                         pop     EBP             ; 
    300                         pop     EBX             ; 
    301                         add     ESP,4           ; 
    302                     } 
     312            version (D_InlineAsm_X86) 
     313            asm 
     314            { 
     315                sub     ESP,4           ; 
     316                push    EBX             ; 
     317                mov     EBX,blockaddr   ; 
     318                push    EBP             ; 
     319                mov     EBP,regebp      ; 
     320                call    EBX             ; 
     321                pop     EBP             ; 
     322                pop     EBX             ; 
     323                add     ESP,4           ; 
     324            } 
     325            else version (D_InlineAsm_X86_64) 
     326            asm 
     327            { 
     328                sub     RSP,8           ; 
     329                push    RBX             ; 
     330                mov     RBX,blockaddr   ; 
     331                push    RBP             ; 
     332                mov     RBP,regebp      ; 
     333                call    RBX             ; 
     334                pop     RBP             ; 
     335                pop     RBX             ; 
     336                add     RSP,8           ; 
     337            } 
     338            else 
     339            static assert(0); 
    303340                } 
    304341                else 
    305342                { 
    306                     asm 
    307                     { 
    308                         push    EBX             ; 
    309                         mov     EBX,blockaddr   ; 
    310                         push    EBP             ; 
    311                         mov     EBP,regebp      ; 
    312                         call    EBX             ; 
    313                         pop     EBP             ; 
    314                         pop     EBX             ; 
    315                     } 
     343            version (D_InlineAsm_X86) 
     344            asm 
     345            { 
     346                push    EBX             ; 
     347                mov     EBX,blockaddr   ; 
     348                push    EBP             ; 
     349                mov     EBP,regebp      ; 
     350                call    EBX             ; 
     351                pop     EBP             ; 
     352                pop     EBX             ; 
     353            } 
     354            else version (D_InlineAsm_X86_64) 
     355            asm 
     356            { 
     357                sub     RSP,8           ; 
     358                push    RBX             ; 
     359                mov     RBX,blockaddr   ; 
     360                push    RBP             ; 
     361                mov     RBP,regebp      ; 
     362                call    RBX             ; 
     363                pop     RBP             ; 
     364                pop     RBX             ; 
     365                add     RSP,8           ; 
     366            } 
     367            else 
     368            static assert(0); 
    316369                } 
    317370            } 
    318371        } 
    319372    } 
    320373} 
    321374 

  • branches/phobos-1.x/phobos/internal/gc/gcbits.d

    r295 r1728  
    8080    //(cast(bit *)(data + 1))[i] = 0; 
    8181    data[1 + (i >> BITS_SHIFT)] &= ~(1 << (i & BITS_MASK)); 
    8282    } 
    8383 
    8484    uint testClear(uint i) 
    8585    { 
    8686    version (bitops) 
    8787    { 
    8888        return std.intrinsic.btr(data + 1, i); 
    8989    } 
    90     else version (Asm86) 
     90    else version (D_InlineAsm_X86) 
    9191    { 
    9292        asm 
    9393        { 
    9494        naked           ; 
    9595        mov EAX,data[EAX]   ; 
    9696        mov ECX,i-4[ESP]    ; 
    9797        btr 4[EAX],ECX  ; 
    9898        sbb EAX,EAX     ; 
    9999        ret 4       ; 
    100100        } 

  • branches/phobos-1.x/phobos/internal/gc/gc.d

    r1334 r1728  
    273273    version (D_InlineAsm_X86) 
    274274    { 
    275275        asm 
    276276        { 
    277277        mov EAX,size    ; 
    278278        mul EAX,length  ; 
    279279        mov size,EAX    ; 
    280280        jc  Loverflow   ; 
    281281        } 
    282282    } 
     283        else version (D_InlineAsm_X86_64) 
     284        asm 
     285        { 
     286        mov RAX,size    ; 
     287        mul RAX,length  ; 
     288        mov size,RAX    ; 
     289        jc  Loverflow   ; 
     290        } 
    283291    else 
    284292        size *= length; 
    285293    p = _gc.malloc(size + 1); 
    286294    debug(PRINTF) printf(" p = %p\n", p); 
    287295    if (!(ti.next.flags() & 1)) 
    288296        _gc.hasNoPointers(p); 
    289297    memset(p, 0, size); 
    290298    result = cast(ulong)length + (cast(ulong)cast(uint)p << 32); 
    291299    } 
    292300    return result; 
    …… 
    314322    version (D_InlineAsm_X86) 
    315323    { 
    316324        asm 
    317325        { 
    318326        mov EAX,size    ; 
    319327        mul EAX,length  ; 
    320328        mov size,EAX    ; 
    321329        jc  Loverflow   ; 
    322330        } 
    323331    } 
     332        else version (D_InlineAsm_X86_64) 
     333        asm 
     334        { 
     335        mov RAX,size    ; 
     336        mul RAX,length  ; 
     337        mov size,RAX    ; 
     338        jc  Loverflow   ; 
     339        } 
    324340    else 
    325341        size *= length; 
    326342    auto p = _gc.malloc(size + 1); 
    327343    debug(PRINTF) 
    328344        printf(" p = %p, isize = %d\n", p, isize); 
    329345    if (!(ti.next.flags() & 1)) 
    330346        _gc.hasNoPointers(p); 
    331347    if (isize == 1) 
    332348        memset(p, *cast(ubyte*)q, size); 
    333349    else if (isize == int.sizeof) 
    …… 
    574590        size_t newsize = void; 
    575591 
    576592        asm 
    577593        { 
    578594        mov EAX,newlength   ; 
    579595        mul EAX,sizeelem    ; 
    580596        mov newsize,EAX ; 
    581597        jc  Loverflow   ; 
    582598        } 
    583599    } 
     600        else version (D_InlineAsm_X86_64) 
     601        asm 
     602        { 
     603        mov RAX,size    ; 
     604        mul RAX,length  ; 
     605        mov size,RAX    ; 
     606        jc  Loverflow   ; 
     607        } 
    584608    else 
    585609    { 
    586610        size_t newsize = sizeelem * newlength; 
    587611 
    588612        if (newsize / newlength != sizeelem) 
    589613        goto Loverflow; 
    590614    } 
    591615    //printf("newsize = %x, newlength = %x\n", newsize, newlength); 
    592616 
    593617    if (p.data) 
    …… 
    677701        size_t newsize = void; 
    678702 
    679703        asm 
    680704        { 
    681705        mov EAX,newlength   ; 
    682706        mul EAX,sizeelem    ; 
    683707        mov newsize,EAX ; 
    684708        jc  Loverflow   ; 
    685709        } 
    686710    } 
     711        else version (D_InlineAsm_X86_64) 
     712        asm 
     713        { 
     714        mov RAX,size    ; 
     715        mul RAX,length  ; 
     716        mov size,RAX    ; 
     717        jc  Loverflow   ; 
     718        } 
    687719    else 
    688720    { 
    689721        size_t newsize = sizeelem * newlength; 
    690722 
    691723        if (newsize / newlength != sizeelem) 
    692724        goto Loverflow; 
    693725    } 
    694726    //printf("newsize = %x, newlength = %x\n", newsize, newlength); 
    695727 
    696728    size_t size = p.length * sizeelem; 

  • branches/phobos-1.x/phobos/internal/gc/gcx.d

    r1371 r1728  
    18241824 
    18251825    /** 
    18261826     * Return number of full pages free'd. 
    18271827     */ 
    18281828    size_t fullcollectshell() 
    18291829    { 
    18301830    // The purpose of the 'shell' is to ensure all the registers 
    18311831    // get put on the stack so they'll be scanned 
    18321832    void *sp; 
    18331833    size_t result; 
    1834     asm 
    1835     { 
    1836         pushad      ; 
    1837         mov sp[EBP],ESP ; 
    1838     } 
     1834    version (D_InlineAsm_X86) 
     1835        asm 
     1836        { 
     1837        pushad      ; 
     1838        mov sp[EBP],ESP ; 
     1839        } 
     1840    else version (D_InlineAsm_X86_64) 
     1841        asm 
     1842        { 
     1843        pushad      ; 
     1844        mov sp[EBP],ESP ; 
     1845        } 
     1846    else 
     1847        static assert(0); 
    18391848    result = fullcollect(sp); 
    18401849    asm 
    18411850    { 
    18421851        popad       ; 
    18431852    } 
    18441853    return result; 
    18451854    } 
    18461855 
    18471856 
    18481857    /** 

  • branches/phobos-1.x/phobos/internal/gc/win32.d

    r295 r1728  
    6767    //printf("pthread_self() = %x\n", GetCurrentThreadId()); 
    6868    return cast(pthread_t) GetCurrentThreadId(); 
    6969} 
    7070 
    7171/********************************************** 
    7272 * Determine "bottom" of stack (actually the top on Win32 systems). 
    7373 */ 
    7474 
    7575void *os_query_stackBottom() 
    7676{ 
    77     asm 
    78     { 
    79     naked           ; 
    80     mov EAX,FS:4    ; 
    81     ret         ; 
    82     } 
     77    version (D_InlineAsm_X86) 
     78    asm 
     79    { 
     80        naked       ; 
     81        mov EAX,FS:4    ; 
     82        ret         ; 
     83    } 
     84   else version (D_InlineAsm_X86_64) 
     85    asm 
     86    { 
     87        naked       ; 
     88        mov RAX,FS:8    ; 
     89        ret         ; 
     90    } 
     91   else 
     92    static assert(0); 
    8393} 
    8494 
    8595/********************************************** 
    8696 * Determine base address and size of static data segment. 
    8797 */ 
    8898 
    8999extern (C) 
    90100{ 
    91101    extern int _xi_a;   // &_xi_a just happens to be start of data segment 
    92102    extern int _edata;  // &_edata is start of BSS segment 

  • branches/phobos-1.x/phobos/internal/llmath.d

    r1701 r1728  
    1212 * Unsigned long divide. 
    1313 * Input: 
    1414 *      [EDX,EAX],[ECX,EBX] 
    1515 * Output: 
    1616 *      [EDX,EAX] = [EDX,EAX] / [ECX,EBX] 
    1717 *      [ECX,EBX] = [EDX,EAX] % [ECX,EBX] 
    1818 */ 
    1919 
    2020void __ULDIV__() 
    2121{ 
     22  version (D_InlineAsm_X86) 
    2223    asm 
    2324    { 
    2425        naked                   ; 
    2526        test    ECX,ECX         ; 
    2627        jz      uldiv           ; 
    2728 
    2829        // if ECX > EDX, then quotient is 0 and remainder is [EDX,EAX] 
    2930        cmp     ECX,EDX         ; 
    3031        ja      quo0            ; 
    3132 
    …… 
    169170quo1:   // Quotient is 1 
    170171        // Remainder is [EDX,EAX] - [ECX,EBX] 
    171172        sub     EAX,EBX         ; 
    172173        sbb     EDX,ECX         ; 
    173174        mov     EBX,EAX         ; 
    174175        mov     ECX,EDX         ; 
    175176        mov     EAX,1           ; 
    176177        xor     EDX,EDX         ; 
    177178        ret                     ; 
    178179    } 
     180  else version (D_InlineAsm_X86_64) 
     181    static assert(0); 
     182  else 
     183    static assert(0); 
    179184} 
    180185 
    181186 
    182187/*************************************** 
    183188 * Signed long divide. 
    184189 * Input: 
    185190 *      [EDX,EAX],[ECX,EBX] 
    186191 * Output: 
    187192 *      [EDX,EAX] = [EDX,EAX] / [ECX,EBX] 
    188193 *      [ECX,EBX] = [EDX,EAX] % [ECX,EBX] 
    189194 *      ESI,EDI destroyed 
    190195 */ 
    191196 
    192197void __LDIV__() 
    193198{ 
     199  version (D_InlineAsm_X86) 
    194200    asm 
    195201    { 
    196202        naked                   ; 
    197203        test    EDX,EDX         ;       // [EDX,EAX] negative? 
    198204        jns     L10             ;       // no 
    199205        //neg64 EDX,EAX         ;       // [EDX,EAX] = -[EDX,EAX] 
    200206          neg   EDX             ; 
    201207          neg   EAX             ; 
    202208          sbb   EDX,0           ; 
    203209        test    ECX,ECX         ;       // [ECX,EBX] negative? 
    …… 
    232238          sbb   ECX,0           ; 
    233239        call    __ULDIV__       ; 
    234240        //neg64 EDX,EAX         ;       // quotient is negative 
    235241          neg   EDX             ; 
    236242          neg   EAX             ; 
    237243          sbb   EDX,0           ; 
    238244        ret                     ; 
    239245 
    240246L12:    jmp     __ULDIV__       ; 
    241247    } 
     248  else version (D_InlineAsm_X86_64) 
     249    static assert(0); 
     250  else 
     251    static assert(0); 
    242252} 
    243253 
    244254 
    245255/*************************************** 
    246256 * Compare [EDX,EAX] with [ECX,EBX] 
    247257 * Signed 
    248258 * Returns result in flags 
    249259 */ 
    250260 
    251261void __LCMP__() 
    252262{ 
     263  version (D_InlineAsm_X86) 
    253264    asm 
    254265    { 
    255266        naked                   ; 
    256267        cmp     EDX,ECX         ; 
    257268        jne     C1              ; 
    258269        push    EDX             ; 
    259270        xor     EDX,EDX         ; 
    260271        cmp     EAX,EBX         ; 
    261272        jz      C2              ; 
    262273        ja      C3              ; 
    263274        dec     EDX             ; 
    264275        pop     EDX             ; 
    265276        ret                     ; 
    266277 
    267278C3:     inc     EDX             ; 
    268279C2:     pop     EDX             ; 
    269280C1:     ret                     ; 
    270281    } 
     282  else version (D_InlineAsm_X86_64) 
     283    static assert(0); 
     284  else 
     285    static assert(0); 
    271286} 
    272287 
    273288 
    274289 
    275290 
    276291// Convert ulong to real 
    277292 
    278293private real adjust = cast(real)0x800_0000_0000_0000 * 0x10; 
    279294 
    280295real __U64_LDBL() 
    281296{ 
    282297    version (OSX) 
    283298    { 
     299      version (D_InlineAsm_X86) 
    284300        asm 
    285301        {   naked                               ; 
    286302            push        EDX                     ; 
    287303            push        EAX                     ; 
    288304            and         dword ptr 4[ESP], 0x7FFFFFFF    ; 
    289305            fild        qword ptr [ESP]         ; 
    290306            test        EDX,EDX                 ; 
    291307            jns         L1                      ; 
    292308            push        0x0000403e              ; 
    293309            push        0x80000000              ; 
    294310            push        0                       ; 
    295311            fld         real ptr [ESP]          ; // adjust 
    296312            add         ESP,12                  ; 
    297313            faddp       ST(1), ST               ; 
    298314        L1:                                     ; 
    299315            add         ESP, 8                  ; 
    300316            ret                                 ; 
    301317        } 
     318      else version (D_InlineAsm_X86_64) 
     319        static assert(0); 
     320      else 
     321        static assert(0); 
    302322    } 
    303323    else 
    304324    { 
     325      version (D_InlineAsm_X86) 
    305326        asm 
    306327        {   naked                               ; 
    307328            push        EDX                     ; 
    308329            push        EAX                     ; 
    309330            and         dword ptr 4[ESP], 0x7FFFFFFF    ; 
    310331            fild        qword ptr [ESP]         ; 
    311332            test        EDX,EDX                 ; 
    312333            jns         L1                      ; 
    313334            fld         real ptr adjust         ; 
    314335            faddp       ST(1), ST               ; 
    315336        L1:                                     ; 
    316337            add         ESP, 8                  ; 
    317338            ret                                 ; 
    318339        } 
     340      else version (D_InlineAsm_X86_64) 
     341        static assert(0); 
     342      else 
     343        static assert(0); 
    319344    } 
    320345} 
    321346 
    322347// Same as __U64_LDBL, but return result as double in [EDX,EAX] 
    323348ulong __ULLNGDBL() 
    324349{ 
     350  version (D_InlineAsm_X86) 
    325351    asm 
    326352    {   naked                                   ; 
    327353        call __U64_LDBL                         ; 
    328354        sub  ESP,8                              ; 
    329355        fstp double ptr [ESP]                   ; 
    330356        pop  EAX                                ; 
    331357        pop  EDX                                ; 
    332358        ret                                     ; 
    333359    } 
     360  else version (D_InlineAsm_X86_64) 
     361        static assert(0); 
     362  else 
     363        static assert(0); 
    334364} 
    335365 
    336366// Convert double to ulong 
    337367 
    338368private short roundTo0 = 0xFBF; 
    339369 
    340370ulong __DBLULLNG() 
    341371{ 
    342372    // BUG: should handle NAN's and overflows 
    343373    version (OSX) 
    344374    { 
     375      version (D_InlineAsm_X86) 
    345376        asm 
    346377        {   naked                               ; 
    347378            push        0xFBF                   ; // roundTo0 
    348379            push        0x0000403e              ; 
    349380            push        0x80000000              ; 
    350381            push        0                       ; // adjust 
    351382            push        EDX                     ; 
    352383            push        EAX                     ; 
    353384            fld         double ptr [ESP]        ; 
    354385            sub         ESP,8                   ; 
    …… 
    369400            add         EDX,0x8000_0000         ; 
    370401            ret                                 ; 
    371402        L1:                                     ; 
    372403            fistp       qword ptr [ESP]         ; 
    373404            pop         EAX                     ; 
    374405            pop         EDX                     ; 
    375406            fldcw       [ESP]                   ; 
    376407            add         ESP,24                  ; 
    377408            ret                                 ; 
    378409        } 
     410      else version (D_InlineAsm_X86_64) 
     411        static assert(0); 
     412      else 
     413        static assert(0); 
    379414    } 
    380415    else 
    381416    { 
     417      version (D_InlineAsm_X86) 
    382418        asm 
    383419        {   naked                               ; 
    384420            push        EDX                     ; 
    385421            push        EAX                     ; 
    386422            fld         double ptr [ESP]        ; 
    387423            sub         ESP,8                   ; 
    388424            fld         real ptr adjust         ; 
    389425            fcomp                               ; 
    390426            fstsw       AX                      ; 
    391427            fstcw       8[ESP]                  ; 
    …… 
    402438            add         EDX,0x8000_0000         ; 
    403439            ret                                 ; 
    404440        L1:                                     ; 
    405441            fistp       qword ptr [ESP]         ; 
    406442            pop         EAX                     ; 
    407443            pop         EDX                     ; 
    408444            fldcw       [ESP]                   ; 
    409445            add         ESP,8                   ; 
    410446            ret                                 ; 
    411447        } 
     448      else version (D_InlineAsm_X86_64) 
     449        static assert(0); 
     450      else 
     451        static assert(0); 
    412452    } 
    413453} 
    414454 
    415455// Convert double in ST0 to uint 
    416456 
    417457uint __DBLULNG() 
    418458{ 
    419459    // BUG: should handle NAN's and overflows 
    420460    version (OSX) 
    421461    { 
     462      version (D_InlineAsm_X86) 
    422463        asm 
    423464        {   naked                               ; 
    424465            push        0xFBF                   ; // roundTo0 
    425466            sub         ESP,12                  ; 
    426467            fstcw       8[ESP]                  ; 
    427468            fldcw       12[ESP]                 ; // roundTo0 
    428469            fistp       qword ptr [ESP]         ; 
    429470            fldcw       8[ESP]                  ; 
    430471            pop         EAX                     ; 
    431472            add         ESP,12                  ; 
    432473            ret                                 ; 
    433474        } 
     475      else version (D_InlineAsm_X86_64) 
     476        static assert(0); 
     477      else 
     478        static assert(0); 
    434479    } 
    435480    else 
    436481    { 
     482      version (D_InlineAsm_X86) 
    437483        asm 
    438484        {   naked                               ; 
    439485            sub         ESP,16                  ; 
    440486            fstcw       8[ESP]                  ; 
    441487            fldcw       roundTo0                ; 
    442488            fistp       qword ptr [ESP]         ; 
    443489            fldcw       8[ESP]                  ; 
    444490            pop         EAX                     ; 
    445491            add         ESP,12                  ; 
    446492            ret                                 ; 
    447493        } 
     494      else version (D_InlineAsm_X86_64) 
     495        static assert(0); 
     496      else 
     497        static assert(0); 
    448498    } 
    449499} 
    450500 
    451501// Convert real in ST0 to ulong 
    452502 
    453503ulong __LDBLULLNG() 
    454504{ 
    455505    version (OSX) 
    456506    { 
     507      version (D_InlineAsm_X86) 
    457508        asm 
    458509        {   naked                               ; 
    459510            push        0xFBF                   ; // roundTo0 
    460511            push        0x0000403e              ; 
    461512            push        0x80000000              ; 
    462513            push        0                       ; // adjust 
    463514            sub         ESP,16                  ; 
    464515            fld         real ptr 16[ESP]        ; // adjust 
    465516            fcomp                               ; 
    466517            fstsw       AX                      ; 
    …… 
    478529            add         EDX,0x8000_0000         ; 
    479530            ret                                 ; 
    480531        L1:                                     ; 
    481532            fistp       qword ptr [ESP]         ; 
    482533            pop         EAX                     ; 
    483534            pop         EDX                     ; 
    484535            fldcw       [ESP]                   ; 
    485536            add         ESP,24                  ; 
    486537            ret                                 ; 
    487538        } 
     539      else version (D_InlineAsm_X86_64) 
     540        static assert(0); 
     541      else 
     542        static assert(0); 
    488543    } 
    489544    else 
    490545    { 
     546      version (D_InlineAsm_X86) 
    491547        asm 
    492548        {   naked                               ; 
    493549            sub         ESP,16                  ; 
    494550            fld         real ptr adjust         ; 
    495551            fcomp                               ; 
    496552            fstsw       AX                      ; 
    497553            fstcw       8[ESP]                  ; 
    498554            fldcw       roundTo0                ; 
    499555            sahf                                ; 
    500556            jae         L1                      ; 
    …… 
    508564            add         EDX,0x8000_0000         ; 
    509565            ret                                 ; 
    510566        L1:                                     ; 
    511567            fistp       qword ptr [ESP]         ; 
    512568            pop         EAX                     ; 
    513569            pop         EDX                     ; 
    514570            fldcw       [ESP]                   ; 
    515571            add         ESP,8                   ; 
    516572            ret                                 ; 
    517573        } 
    518     } 
    519 } 
    520  
     574      else version (D_InlineAsm_X86_64) 
     575        static assert(0); 
     576      else 
     577        static assert(0); 
     578    } 
     579} 
     580 

  • branches/phobos-1.x/phobos/internal/trace.d

    r1701 r1728  
    775775     *  ascii   string 
    776776     * or: 
    777777     *  db      0x0FF 
    778778     *  db      0 
    779779     *  dw      length 
    780780     *  ascii   string 
    781781     */ 
    782782 
    783783  version (OSX) 
    784784  { // 16 byte align stack 
     785   version (D_InlineAsm_X86) 
    785786    asm 
    786787    {   naked                           ; 
    787788        pushad                          ; 
    788789        mov     ECX,8*4[ESP]            ; 
    789790        xor     EAX,EAX                 ; 
    790791        mov     AL,[ECX]                ; 
    791792        cmp     AL,0xFF                 ; 
    792793        jne     L1                      ; 
    793794        cmp     byte ptr 1[ECX],0       ; 
    794795        jne     L1                      ; 
    …… 
    800801        add     8*4[ESP],EAX            ; 
    801802        dec     EAX                     ; 
    802803        sub     ESP,4                   ; 
    803804        push    ECX                     ; 
    804805        push    EAX                     ; 
    805806        call    trace_pro               ; 
    806807        add     ESP,12                  ; 
    807808        popad                           ; 
    808809        ret                             ; 
    809810    } 
     811      else version (D_InlineAsm_X86_64) 
     812        static assert(0); 
     813      else 
     814        static assert(0); 
    810815  } 
    811816  else 
    812817  { 
     818   version (D_InlineAsm_X86) 
    813819    asm 
    814820    {   naked                           ; 
    815821        pushad                          ; 
    816822        mov     ECX,8*4[ESP]            ; 
    817823        xor     EAX,EAX                 ; 
    818824        mov     AL,[ECX]                ; 
    819825        cmp     AL,0xFF                 ; 
    820826        jne     L1                      ; 
    821827        cmp     byte ptr 1[ECX],0       ; 
    822828        jne     L1                      ; 
    …… 
    827833        inc     ECX                     ; 
    828834        add     8*4[ESP],EAX            ; 
    829835        dec     EAX                     ; 
    830836        push    ECX                     ; 
    831837        push    EAX                     ; 
    832838        call    trace_pro               ; 
    833839        add     ESP,8                   ; 
    834840        popad                           ; 
    835841        ret                             ; 
    836842    } 
     843      else version (D_InlineAsm_X86_64) 
     844        static assert(0); 
     845      else 
     846        static assert(0); 
    837847  } 
    838848} 
    839849 
    840850///////////////////////////////////////////// 
    841851// Function called by trace code in function epilog. 
    842852 
    843853 
    844854void _trace_epi_n() 
    845855{ 
    846856  version (OSX) 
    847857  { // 16 byte align stack 
     858   version (D_InlineAsm_X86) 
     859   { 
    848860    asm 
    849861    {   naked   ; 
    850862        pushad  ; 
    851863        sub     ESP,12  ; 
    852864    } 
    853865    trace_epi(); 
    854866    asm 
    855867    { 
    856868        add     ESP,12  ; 
    857869        popad   ; 
    858870        ret     ; 
    859871    } 
     872   } 
     873      else version (D_InlineAsm_X86_64) 
     874        static assert(0); 
     875      else 
     876        static assert(0); 
    860877  } 
    861878  else 
    862879  { 
     880   version (D_InlineAsm_X86) 
     881   { 
    863882    asm 
    864883    {   naked   ; 
    865884        pushad  ; 
    866885    } 
    867886    trace_epi(); 
    868887    asm 
    869888    { 
    870889        popad   ; 
    871890        ret     ; 
    872891    } 
     892   } 
     893      else version (D_InlineAsm_X86_64) 
     894        static assert(0); 
     895      else 
     896        static assert(0); 
    873897  } 
    874898} 
    875899 
    876900 
    877901version (Win32) 
    878902{ 
    879903    extern (Windows) 
    880904    { 
    881905        export int QueryPerformanceCounter(timer_t *); 
    882906        export int QueryPerformanceFrequency(timer_t *); 
    883907    } 
    884908} 
    885909else version (X86) 
    886910{ 
    887911    extern (D) 
    888912    { 
    889913        void QueryPerformanceCounter(timer_t* ctr) 
    890914        { 
     915      version (D_InlineAsm_X86) 
    891916            asm 
    892917            {   naked                   ; 
    893918                mov       ECX,EAX       ; 
    894919                rdtsc                   ; 
    895920                mov   [ECX],EAX         ; 
    896921                mov   4[ECX],EDX        ; 
    897922                ret                     ; 
    898923            } 
     924      else version (D_InlineAsm_X86_64) 
     925        static assert(0); 
     926      else 
     927        static assert(0); 
    899928        } 
    900929 
    901930        void QueryPerformanceFrequency(timer_t* freq) 
    902931        { 
    903932            *freq = 3579545; 
    904933        } 
    905934    } 
    906935} 
    907936else 
    908937{ 

  • branches/phobos-1.x/phobos/std/cpuid.d

    r1539 r1728  
    215215    uint maxCores=1; 
    216216    uint manufac=OTHER; 
    217217 
    218218    /* ** 
    219219     * fetches the cpu vendor string 
    220220     */ 
    221221    private void getVendorString() 
    222222    { 
    223223        char* dst = vendorStr.ptr; 
    224224        // puts the vendor string into dst 
    225         asm 
    226         { 
    227             mov EAX, 0                  ; 
    228             cpuid                       ; 
    229             mov EAX, dst                ; 
    230             mov [EAX], EBX              ; 
    231             mov [EAX+4], EDX            ; 
    232             mov [EAX+8], ECX            ; 
    233         } 
     225    version (D_InlineAsm_X86) 
     226        asm 
     227        { 
     228        mov EAX, 0                  ; 
     229        cpuid                       ; 
     230        mov EAX, dst                ; 
     231        mov [EAX], EBX              ; 
     232        mov [EAX+4], EDX            ; 
     233        mov [EAX+8], ECX            ; 
     234        } 
     235    else version (D_InlineAsm_X86_64) 
     236        static assert(0); 
     237    else 
     238        static assert(0); 
    234239    } 
    235240 
    236241    private void getProcessorString() 
    237242    { 
    238243        char[48] buffer; 
    239244        char* dst = buffer.ptr; 
    240245        // puts the processor string into dst 
     246    version (D_InlineAsm_X86) 
    241247        asm 
    242248        { 
    243249            mov EAX, 0x8000_0000        ; 
    244250            cpuid                       ; 
    245251            cmp EAX, 0x8000_0004        ; 
    246252            jb PSLabel                  ; // no support 
    247253            push EDI                    ; 
    248254            mov EDI, dst                ; 
    249255            mov EAX, 0x8000_0002        ; 
    250256            cpuid                       ; 
    …… 
    260266            mov [EDI+28], EDX           ; 
    261267            mov EAX, 0x8000_0004        ; 
    262268            cpuid                       ; 
    263269            mov [EDI+32], EAX           ; 
    264270            mov [EDI+36], EBX           ; 
    265271            mov [EDI+40], ECX           ; 
    266272            mov [EDI+44], EDX           ; 
    267273            pop EDI                     ; 
    268274        PSLabel:                        ; 
    269275        } 
     276    else version (D_InlineAsm_X86_64) 
     277        static assert(0); 
     278    else 
     279        static assert(0); 
    270280 
    271281        if (buffer[0] == char.init) // no support 
    272282            return; 
    273283 
    274284        // seems many intel processors prepend whitespace 
    275285        processorStr = std.string.strip(std.string.toString(dst)).dup; 
    276286    } 
    277287 
    278288    private void getFeatureFlags() 
    279289    { 
    280290        uint f,m,e,a,s; 
     291    version (D_InlineAsm_X86) 
    281292        asm 
    282293        { 
    283294            mov EAX, 0                  ; 
    284295            cpuid                       ; 
    285296            cmp EAX, 1                  ; 
    286297            jb FeatLabel                ; // no support 
    287298            mov EAX, 1                  ; 
    288299            cpuid                       ; 
    289300            mov f, EDX                  ; 
    290301            mov m, ECX                  ; 
    …… 
    296307            cpuid                       ; 
    297308            cmp EAX, 0x8000_0001        ; 
    298309            jb FeatLabel2               ; // no support 
    299310            mov EAX, 0x8000_0001        ; 
    300311            cpuid                       ; 
    301312            mov e, EDX                  ; 
    302313 
    303314        FeatLabel2: 
    304315            ; 
    305316        } 
     317    else version (D_InlineAsm_X86_64) 
     318        static assert(0); 
     319    else 
     320        static assert(0); 
    306321        flags = f; 
    307322        misc = m; 
    308323        exflags = e; 
    309324        apic = a; 
    310325        signature = s; 
    311326    } 
    312327 
    313328    private void getThreadingIntel() 
    314329    { 
    315330        uint n; 
    316331        ubyte b = 0; 
     332    version (D_InlineAsm_X86) 
    317333        asm 
    318334        { 
    319335            mov EAX, 0                  ; 
    320336            cpuid                       ; 
    321337            cmp EAX, 4                  ; 
    322338            jb IntelSingle              ; 
    323339            mov EAX, 4                  ; 
    324340            mov ECX, 0                  ; 
    325341            cpuid                       ; 
    326342            mov n, EAX                  ; 
    327343            mov b, 1                    ; 
    328344        IntelSingle:                    ; 
    329345        } 
     346    else version (D_InlineAsm_X86_64) 
     347        static assert(0); 
     348    else 
     349        static assert(0); 
    330350        if (b != 0) 
    331351        { 
    332352            maxCores = ((n>>>26)&0x3F)+1; 
    333353            maxThreads = (apic>>>16)&0xFF; 
    334354        } 
    335355        else 
    336356        { 
    337357            maxCores = maxThreads = 1; 
    338358        } 
    339359    } 
    340360 
    341361    private void getThreadingAMD() 
    342362    { 
    343363        ubyte n; 
    344364        ubyte b = 0; 
     365    version (D_InlineAsm_X86) 
    345366        asm 
    346367        { 
    347368            mov EAX, 0x8000_0000        ; 
    348369            cpuid                       ; 
    349370            cmp EAX, 0x8000_0008        ; 
    350371            jb AMDSingle                ; 
    351372            mov EAX, 0x8000_0008        ; 
    352373            cpuid                       ; 
    353374            mov n, CL                   ; 
    354375            mov b, 1                    ; 
    355376        AMDSingle:                      ; 
    356377        } 
     378    else version (D_InlineAsm_X86_64) 
     379        static assert(0); 
     380    else 
     381        static assert(0); 
    357382        if (b != 0) 
    358383        { 
    359384            maxCores = n+1; 
    360385            maxThreads = (apic>>>16)&0xFF; 
    361386        } 
    362387        else 
    363388        { 
    364389            maxCores = maxThreads = 1; 
    365390        } 
    366391    } 

  • branches/phobos-1.x/phobos/std/math.d

    r1539 r1728  
    384384 *      $(TABLE_SV 
    385385 *      $(TR $(TH x)             $(TH tan(x))       $(TH invalid?)) 
    386386 *      $(TR $(TD $(NAN))        $(TD $(NAN))       $(TD yes)) 
    387387 *      $(TR $(TD $(PLUSMN)0.0)  $(TD $(PLUSMN)0.0) $(TD no)) 
    388388 *      $(TR $(TD $(PLUSMNINF))  $(TD $(NAN))       $(TD yes)) 
    389389 *      ) 
    390390 */ 
    391391 
    392392real tan(real x) 
    393393{ 
    394     version(Naked_D_InlineAsm_X86) { 
     394    version(Naked_D_InlineAsm_X86) 
     395    { 
    395396    asm 
    396397    { 
    397398        fld     x[EBP]                  ; // load theta 
    398399        fxam                            ; // test for oddball values 
    399400        fstsw   AX                      ; 
    400401        sahf                            ; 
    401402        jc      trigerr                 ; // x is NAN, infinity, or empty 
    402403                                          // 387's can handle denormals 
    403404SC18:   fptan                           ; 
    404405        fstp    ST(0)                   ; // dump X, which is always 1 

  • branches/phobos-1.x/phobos/std/thread.d

    r1539 r1728  
    599599     } 
    600600} 
    601601 
    602602 
    603603/********************************************** 
    604604 * Determine "bottom" of stack (actually the top on Win32 systems). 
    605605 */ 
    606606 
    607607void *os_query_stackBottom() 
    608608{ 
     609    version (D_InlineAsm_X86) 
    609610    asm 
    610611    { 
    611612        naked                   ; 
    612613        mov     EAX,FS:4        ; 
    613614        ret                     ; 
    614615    } 
     616    else version (D_InlineAsm_X86_64) 
     617    asm 
     618    { 
     619        naked                   ; 
     620        mov     RAX,FS:8        ; 
     621        ret                     ; 
     622    } 
     623    else 
     624    static assert(0); 
    615625} 
    616626 
    617627} 
    618628 
    619629/* ================================ Posix ================================= */ 
    620630 
    621631version (Posix) 
    622632{ 
    623633private import std.c.posix.posix; 
    624634private import std.c.posix.pthread; 
    …… 
    11931203        extern (C) static void resumeHandler(int sig) 
    11941204        { 
    11951205        Thread t = getThis(); 
    11961206 
    11971207        t.flags |= 1; 
    11981208        } 
    11991209    } 
    12001210 
    12011211    public static void* getESP() 
    12021212    { 
    1203         asm 
    1204         {   naked       ; 
    1205             mov EAX,ESP ; 
    1206             ret         ; 
    1207         } 
     1213    version (D_InlineAsm_X86) 
     1214        asm 
     1215        {   naked       ; 
     1216        mov EAX,ESP ; 
     1217        ret         ; 
     1218        } 
     1219    else version (D_InlineAsm_X86_64) 
     1220        asm 
     1221        {   naked       ; 
     1222        mov RAX,RSP ; 
     1223        ret         ; 
     1224        } 
     1225    else 
     1226        static assert(0); 
    12081227    } 
    12091228} 
    12101229 
    12111230 
    12121231} 
    12131232 

  • branches/phobos-1.x/phobos/std/windows/registry.d

    r1539 r1728  
    353353        case    Endian.Little: 
    354354            return REG_VALUE_TYPE.REG_DWORD_LITTLE_ENDIAN; 
    355355 
    356356        default: 
    357357            throw new RegistryException("Invalid Endian specified"); 
    358358    } 
    359359} 
    360360 
    361361private uint swap(in uint i) 
    362362{ 
    363     version(X86) 
     363    version (D_InlineAsm_X86) 
     364    { 
     365        asm 
     366        {    naked; 
     367             bswap EAX ; 
     368             ret ; 
     369        } 
     370    } 
     371    else version (D_InlineAsm_X86_64) 
    364372    { 
    365373        asm 
    366374        {    naked; 
    367375             bswap EAX ; 
    368376             ret ; 
    369377        } 
    370378    } 
    371379    else 
    372380    { 
    373381        uint    v_swap  =   (i & 0xff) << 24