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

Ticket #2038: 64Bit.13.patch

File 64Bit.13.patch, 141.1 kB (added by Marenz, 13 years ago)

found some more missing version()s. Fixed tango layout class. unittests run up to a certain point.

  • build/script/unittest.sh

    old new  
    99EXE=runUnittests_$DC 
    1010DL="-L-ldl" 
    1111UNAME=`uname` 
    12 OPTIONS="-debug -debug=UnitTest" 
     12OPTIONS="-debug -debug=UnitTest" #  :w -debug=PRINTF" 
    1313 
    1414error () { 
    1515    echo "Example : DC=dmd PLATFORM=linux ARCH=32 build/script/unittest.sh" 
    …… 
    3333    OPTIONS="-oq -d-debug -d-debug=UnitTest" 
    3434fi 
    3535 
    36 build/bin/$PLATFORM$ARCH/bob -v -r=$DC -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o="-g -unittest $OPTIONS" .  
     36echo build/bin/${PLATFORM}32/bob -r=$DC -v -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o=\"-m$ARCH -gc -unittest $OPTIONS\" .  
     37build/bin/${PLATFORM}32/bob -r=$DC -v -c=$DC -p=$PLATFORM -l=libtango-$DC-tst -o="-m$ARCH -gc -unittest $OPTIONS" .  
    3738 
     39 
     40echo "Compiled" 
     41 
    3842if ! which $DC >& /dev/null 
    3943then 
    4044    echo "$DC not found on your \$PATH!" 
    …… 
    99103    DL="" 
    100104fi 
    101105 
    102 echo "$DC $EXE.d $DFILES -g $OPTIONS -unittest -L-L. -L-ltango-$DC-tst  $DL -L-lz -L-lbz2" 
    103 $DC $EXE.d $DFILES -g $OPTIONS -unittest -L-L. -L-ltango-$DC-tst  $DL -L-lz -L-lbz2  && rm $EXE.d && rm libtango-$DC-tst.a 
     106echo "$DC $EXE.d $DFILES -gc $OPTIONS -m$ARCH -unittest -L-L. -L-ltango-$DC-tst  $DL -L-lz -L-lbz2" 
     107$DC $EXE.d $DFILES -gc $OPTIONS -m$ARCH -unittest -L-L. -L-ltango-$DC-tst  $DL -L-lz -L-lbz2  #&& rm $EXE.d && rm libtango-$DC-tst.a 
    104108 
    105109./runUnittests_$DC 
    106110 

  • build/src/bob.d

    old new  
    3838           new FreeBSD (args); 
    3939           new Solaris (args); 
    4040           new Windows (args); 
    41            stdout.formatln ("{} files", FileFilter.builder(args.os, args.compiler)()); 
     41           Stdout.formatln ("{} files", FileFilter.builder(args.os, args.compiler)()); 
    4242           } 
    4343} 
    4444 
    …… 
    170170 
    171171                if (args.core) { 
    172172                    foreach (file; scan(".c")) { 
    173                              auto obj = compile (file, gcc32); 
     173                             auto obj = compile (file, gcc); 
    174174                             addToLib(obj); 
    175175                    } 
    176176 
    177177                    foreach (file; scan(".S")) { 
    178                             auto obj = compile (file, gcc32); 
     178                            auto obj = compile (file, gcc); 
    179179                            addToLib(obj); 
    180180                    } 
    181181                } 
    …… 
    780780                if (args.verbose) 
    781781                   { 
    782782                   foreach (str; cmd) 
    783                             stdout (str)(' '); 
    784                    stdout.newline; 
     783                            Stdout (str)(' '); 
     784                   Stdout.newline; 
    785785                   }   
    786786                          
    787787                if (! args.inhibit) 
    …… 
    794794                       proc.copyEnv (true); 
    795795 
    796796                   proc.execute(); 
    797                    stdout.stream.copy (proc.stderr); 
    798                    stdout.stream.copy (proc.stdout); 
     797                   Stdout.stream.copy (proc.stderr); 
     798                   Stdout.stream.copy (proc.stdout); 
    799799                   auto result = proc.wait; 
    800800                   if (result.reason != Process.Result.Exit) 
    801801                       throw new Exception (result.toString); 

  • object.di

    old new  
    119119    equals_t      equals(void *p1, void *p2); 
    120120    /// compares the types of this TypeInfo stored at p1 and p2 
    121121    int      compare(void *p1, void *p2); 
     122     /// Return alignment of type 
     123    size_t   talign() { return tsize(); } 
    122124    /// returns the size of a type with the current TypeInfo 
    123125    size_t   tsize(); 
    124126    /// swaps the two types stored at p1 and p2 
    …… 
    131133    PointerMap pointermap(); 
    132134    /// offsets of the various elements 
    133135    OffsetTypeInfo[] offTi(); 
     136 
     137    /** Return internal info on arguments fitting into 8byte. 
     138       * See X86-64 ABI 3.2.3 
     139     */ 
     140    version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2); 
    134141} 
    135142 
    136143class TypeInfo_Typedef : TypeInfo 

  • tango/text/convert/Layout.d

    old new  
    6666        alias void* Arg; 
    6767        alias va_list ArgList; 
    6868        } 
     69else version(DigitalMars) 
     70        { 
     71        private import tango.core.Vararg; 
     72        alias void* Arg; 
     73        alias va_list ArgList; 
     74        } 
    6975     else 
    7076        { 
    7177        alias void* Arg; 
    …… 
    111117 
    112118        public final T[] sprint (T[] result, T[] formatStr, ...) 
    113119        { 
     120                version (X86_64) 
     121                { 
     122                    va_list ap; 
     123 
     124                    va_start(ap, __va_argsave); 
     125 
     126                    scope(exit) va_end(ap); 
     127 
     128                    return vprint (result, formatStr, _arguments, ap); 
     129                } 
     130                else 
    114131                return vprint (result, formatStr, _arguments, _argptr); 
    115132        } 
    116133 
    …… 
    175192 
    176193        public final T[] convert (T[] formatStr, ...) 
    177194        { 
     195                version (X86_64) 
     196                { 
     197                    va_list ap; 
     198 
     199                    va_start(ap, __va_argsave); 
     200 
     201                    scope(exit) va_end(ap); 
     202 
     203                    return convert (_arguments, ap, formatStr); 
     204                } 
     205                else 
    178206                return convert (_arguments, _argptr, formatStr); 
    179207        } 
    180208 
    …… 
    184212 
    185213        public final uint convert (Sink sink, T[] formatStr, ...) 
    186214        { 
     215                version (X86_64) 
     216                { 
     217                    va_list ap; 
     218 
     219                    va_start(ap, __va_argsave); 
     220 
     221                    scope(exit) va_end(ap); 
     222 
     223                    return convert (sink, _arguments, ap, formatStr); 
     224                } 
     225                else 
    187226                return convert (sink, _arguments, _argptr, formatStr); 
    188227        } 
    189228 
    …… 
    203242                        return output.write(s); 
    204243                } 
    205244 
     245 
     246                version (X86_64) 
     247                { 
     248                    va_list ap; 
     249 
     250                    va_start(ap, __va_argsave); 
     251 
     252                    scope(exit) va_end(ap); 
     253 
     254                    return convert (&sink, _arguments, ap, formatStr); 
     255                } 
     256                else 
    206257                return convert (&sink, _arguments, _argptr, formatStr); 
    207258        } 
    208259 
    …… 
    224275                return output; 
    225276        } 
    226277 
    227 version (old) 
    228 { 
    229278        /********************************************************************** 
    230279 
    231280        **********************************************************************/ 
    232281 
    233         public final T[] convertOne (T[] result, TypeInfo ti, Arg arg) 
     282        version (old) public final T[] convertOne (T[] result, TypeInfo ti, Arg arg) 
    234283        { 
    235284                return dispatch (result, null, ti, arg); 
    236285        } 
    237 } 
     286 
    238287        /********************************************************************** 
    239288 
    240289        **********************************************************************/ 
    …… 
    336385                                   } 
    337386                                } 
    338387                        } 
    339                      else 
     388                    else version(X86) 
    340389                        { 
    341390                        Arg[64] arglist = void; 
    342391                        foreach (i, arg; arguments) 
    …… 
    345394                                args += (arg.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1); 
    346395                                } 
    347396                        } 
     397                    else version(X86_64) 
     398                    { 
     399                        Arg[64] arglist = void; 
     400                        void[] buffer; 
     401                        uint len = 0; 
     402 
     403                        foreach(i, argType; arguments) 
     404                            len +=  (argType.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1); 
     405 
     406                        buffer.length = len; 
     407                        len = 0; 
     408                        foreach(i, argType; arguments) 
     409                        { 
     410                            va_arg(args, argType, buffer.ptr+len); 
     411 
     412                            arglist[i] = &buffer[len]; 
     413 
     414                            len+= (argType.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1); 
     415                        } 
     416 
     417                        scope (exit) delete buffer; 
     418                    } 
    348419                return parse (formatStr, arguments, arglist, sink); 
    349420        } 
    350421 

  • tango/text/Text.d

    old new  
    213213 
    214214private import tango.stdc.string : memmove; 
    215215 
     216version(DigitalMars) 
     217{ 
     218    private import tango.core.Vararg; 
     219} 
    216220 
    217221/******************************************************************************* 
    218222 

  • tango/io/Console.d

    old new  
    638638        Cerr = new Console.Output (conduit, conduit.redirected); 
    639639} 
    640640 
    641  
    642641/****************************************************************************** 
    643642 
    644643        Flush outputs before we exit. 

  • tango/io/stream/Snoop.d

    old new  
    1717 
    1818private import  tango.text.convert.Format; 
    1919 
     20version(DigitalMars) 
     21{ 
     22    private import tango.core.Vararg; 
     23} 
     24 
    2025private alias void delegate(char[]) Snoop; 
    2126 
    2227/******************************************************************************* 

  • tango/io/stream/Format.d

    old new  
    1616 
    1717private import tango.text.convert.Layout; 
    1818 
     19version(DigitalMars) 
     20{ 
     21    private import tango.core.Vararg; 
     22} 
     23 
    1924/******************************************************************************* 
    2025 
    2126        A bridge between a Layout instance and a stream. This is used for 

  • tango/core/rt/gc/basic/gcx.d

    old new  
    6464    private import gcc.builtins; // for __builtin_unwind_init 
    6565} 
    6666 
     67extern (C) uint sleep(uint seconds); 
    6768 
    6869struct BlkInfo 
    6970{ 
    …… 
    16661667     */ 
    16671668    void addRange(void *pbot, void *ptop) 
    16681669    { 
    1669         debug(PRINTF) printf("Thread %x ", pthread_self()); 
     1670        debug(PRINTF) debug(THREADINVARIANT) printf("Thread %x ", pthread_self()); 
    16701671        debug(PRINTF) printf("%x.Gcx::addRange(%x, %x), nranges = %d\n", this, pbot, ptop, nranges); 
    16711672        if (nranges == rangedim) 
    16721673        { 
    …… 
    16941695     */ 
    16951696    void removeRange(void *pbot) 
    16961697    { 
    1697         debug(PRINTF) printf("Thread %x ", pthread_self()); 
     1698        debug(PRINTF) debug(THREADINVARIANT) printf("Thread %x ", pthread_self()); 
    16981699        debug(PRINTF) printf("%x.Gcx.removeRange(%x), nranges = %d\n", this, pbot, nranges); 
    16991700        for (size_t i = nranges; i--;) 
    17001701        { 
    …… 
    20982099        size_t newnpools; 
    20992100        size_t i; 
    21002101 
    2101         //debug(PRINTF) printf("************Gcx::newPool(npages = %d)****************\n", npages); 
    21022102 
     2103        debug(PRINTF) printf("************Gcx::newPool(npages = %x)****************\n", npages); 
     2104if ( npages > 0xc5e00010 ) 
     2105    sleep ( 5); 
     2106 
    21032107        // Round up to COMMITSIZE pages 
    21042108        npages = (npages + (COMMITSIZE/PAGESIZE) - 1) & ~(COMMITSIZE/PAGESIZE - 1); 
    21052109 
    …… 
    23442348        } 
    23452349        else 
    23462350        { 
     2351        version (D_InlineAsm_X86) 
     2352        { 
    23472353        asm 
    23482354        { 
    23492355            pushad              ; 
    23502356            mov sp[EBP],ESP     ; 
    23512357        } 
    23522358        } 
     2359        else version (D_InlineAsm_X86_64) 
     2360        { 
     2361            asm 
     2362            { 
     2363                push RAX ; 
     2364                push RBX ; 
     2365                push RCX ; 
     2366                push RDX ; 
     2367                push RSI ; 
     2368                push RDI ; 
     2369                push RBP ; 
     2370                push R8  ; 
     2371                push R9  ; 
     2372                push R10  ; 
     2373                push R11  ; 
     2374                push R12  ; 
     2375                push R13  ; 
     2376                push R14  ; 
     2377                push R15  ; 
     2378                push EAX ;   // 16 byte align the stack 
     2379            } 
     2380        } 
     2381        else 
     2382        { 
     2383            static assert( false, "Architecture not supported." ); 
     2384        } 
     2385        } 
    23532386        result = fullcollect(sp); 
    23542387        version (GNU) 
    23552388        { 
    …… 
    23592392        { 
    23602393            // nothing to do 
    23612394        } 
    2362         else 
     2395        else version (D_InlineAsm_X86) 
    23632396        { 
    23642397        asm 
    23652398        { 
    23662399            popad               ; 
    23672400        } 
    23682401        } 
     2402        else version (D_InlineAsm_X86_64) 
     2403        { 
     2404            asm 
     2405            { 
     2406                pop EAX ;   // 16 byte align the stack 
     2407                pop R15  ; 
     2408                pop R14  ; 
     2409                pop R13  ; 
     2410                pop R12  ; 
     2411                pop R11  ; 
     2412                pop R10  ; 
     2413                pop R9  ; 
     2414                pop R8  ; 
     2415                pop RBP ; 
     2416                pop RDI ; 
     2417                pop RSI ; 
     2418                pop RDX ; 
     2419                pop RCX ; 
     2420                pop RBX ; 
     2421                pop RAX ; 
     2422            } 
     2423        } 
     2424        else 
     2425        { 
     2426            static assert( false, "Architecture not supported." ); 
     2427        } 
    23692428        return result; 
    23702429    } 
    23712430 
    …… 
    24712530                    } 
    24722531                    *b = 0; 
    24732532 
    2474                     auto o = pool.baseAddr + (b - bbase) * 32 * 16; 
     2533                    auto o = pool.baseAddr + (b - bbase) * (typeof(bitm).sizeof*8) * 16; 
    24752534                    if (!(bitm & 0xFFFF)) 
    24762535                    { 
    24772536                        bitm >>= 16; 
    …… 
    25192578        for (n = 0; n < npools; n++) 
    25202579        {   size_t pn; 
    25212580            size_t ncommitted; 
    2522             uint*  bbase; 
    25232581 
    25242582            pool = pooltable[n]; 
    2525             bbase = pool.mark.base(); 
     2583            auto bbase = pool.mark.base(); 
    25262584            ncommitted = pool.ncommitted; 
    25272585            for (pn = 0; pn < ncommitted; pn++, bbase += PAGESIZE / (32 * 16)) 
    25282586            { 
    …… 
    25712629                            sentinel_Invariant(sentinel_add(p)); 
    25722630 
    25732631                            pool.freebits.set(biti); 
     2632 
    25742633                            if (pool.finals.nbits && pool.finals.testClear(biti)) 
    25752634                                rt_finalize(cast(List *)sentinel_add(p), false/*noStack > 0*/); 
    25762635                            clrBits(pool, biti, BlkAttr.ALL_BITS); 
    …… 
    29092968        //debug(PRINTF) printf("Pool::Pool(%u)\n", npages); 
    29102969        poolsize = npages * PAGESIZE; 
    29112970        assert(poolsize >= POOLSIZE); 
     2971 
     2972        debug(PRINTF) printf("alloc of pool: %p bytes\n", poolsize); 
     2973 
    29122974        baseAddr = cast(byte *)os_mem_map(poolsize); 
    29132975 
    29142976        // Some of the code depends on page alignment of memory pools 

  • tango/core/rt/gc/basic/gcalloc.d

    old new  
    115115} 
    116116else static if (is(typeof(mmap)))  // else version (GC_Use_Alloc_MMap) 
    117117{ 
     118    debug(PRINTF) import tango.stdc.stdio: printf; 
     119 
     120 
    118121    void *os_mem_map(size_t nbytes) 
    119122    {   void *p; 
    120123 
     124        debug(PRINTF) printf("mmap alloc of %p bytes\n", nbytes); 
    121125        p = mmap(null, nbytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); 
    122126        return (p == MAP_FAILED) ? null : p; 
    123127    } 

  • tango/core/rt/gc/basic/gcbits.d

    old new  
    5050 
    5151struct GCBits 
    5252{ 
    53     const int BITS_PER_WORD = 32; 
    54     const int BITS_SHIFT = 5; 
    55     const int BITS_MASK = 31; 
     53    alias size_t wordtype; 
    5654 
    57     uint*  data = null; 
     55    const BITS_PER_WORD = (wordtype.sizeof * 8); 
     56    const BITS_SHIFT = (wordtype.sizeof == 8 ? 6 : 5); 
     57    const BITS_MASK = (BITS_PER_WORD - 1); 
     58    const BITS_1 = cast(wordtype)1; 
     59 
     60    wordtype*  data = null; 
    5861    size_t nwords = 0;    // allocated words in data[] excluding sentinals 
    5962    size_t nbits = 0;     // number of bits in data[] excluding sentinals 
    6063 
    …… 
    7982    { 
    8083        this.nbits = nbits; 
    8184        nwords = (nbits + (BITS_PER_WORD - 1)) >> BITS_SHIFT; 
    82         data = cast(uint*)calloc(nwords + 2, uint.sizeof); 
     85        data = cast(wordtype*)calloc(nwords + 2, wordtype.sizeof); 
    8386        if (!data) 
    8487            onOutOfMemoryError(); 
    8588    } 
    8689 
    87     uint test(size_t i) 
     90    wordtype test(size_t i) 
    8891    in 
    8992    { 
    9093        assert(i < nbits); 
    …… 
    9295    body 
    9396    { 
    9497        //return (cast(bit *)(data + 1))[i]; 
    95         return data[1 + (i >> BITS_SHIFT)] & (1 << (i & BITS_MASK)); 
     98        return data[1 + (i >> BITS_SHIFT)] & (BITS_1 << (i & BITS_MASK)); 
    9699    } 
    97100 
    98101    void set(size_t i) 
    …… 
    103106    body 
    104107    { 
    105108        //(cast(bit *)(data + 1))[i] = 1; 
    106         data[1 + (i >> BITS_SHIFT)] |= (1 << (i & BITS_MASK)); 
     109        data[1 + (i >> BITS_SHIFT)] |= (BITS_1 << (i & BITS_MASK)); 
    107110    } 
    108111 
    109112    void clear(size_t i) 
    …… 
    114117    body 
    115118    { 
    116119        //(cast(bit *)(data + 1))[i] = 0; 
    117         data[1 + (i >> BITS_SHIFT)] &= ~(1 << (i & BITS_MASK)); 
     120        data[1 + (i >> BITS_SHIFT)] &= ~(BITS_1 << (i & BITS_MASK)); 
    118121    } 
    119122 
    120     uint testClear(size_t i) 
     123    wordtype testClear(size_t i) 
    121124    { 
    122125        version (bitops) 
    123126        { 
    …… 
    136139            } 
    137140        } 
    138141        else 
    139         {   uint result; 
     142        {   wordtype result; 
    140143 
    141144            //result = (cast(bit *)(data + 1))[i]; 
    142145            //(cast(bit *)(data + 1))[i] = 0; 
    143146 
    144             uint* p = &data[1 + (i >> BITS_SHIFT)]; 
    145             uint  mask = (1 << (i & BITS_MASK)); 
     147            wordtype* p = &data[1 + (i >> BITS_SHIFT)]; 
     148            wordtype  mask = (BITS_1 << (i & BITS_MASK)); 
    146149            result = *p & mask; 
    147150            *p &= ~mask; 
    148151            return result; 
    …… 
    188191            for (;d1!=dEnd;++d1) 
    189192                *d1=0u; 
    190193        } else { 
    191             memset(data + 1, 0, nwords * uint.sizeof); 
     194            memset(data + 1, 0, nwords * wordtype.sizeof); 
    192195        } 
    193196    } 
    194197 
    …… 
    200203    body 
    201204    { 
    202205        version(MEMCPY_NON_SIG_SAFE) { 
    203             uint * d1=data+1,d2=f.data+1,dEnd=d1+nwords; 
     206            wordtype * d1=data+1,d2=f.data+1,dEnd=d1+nwords; 
    204207            for (;d1!=dEnd;++d1,++d2) 
    205208                *d1=*d2; 
    206209        } else { 
    207             memcpy(data + 1, f.data + 1, nwords * uint.sizeof); 
     210            memcpy(data + 1, f.data + 1, nwords * wordtype.sizeof); 
    208211        } 
    209212    } 
    210213 
    211     uint* base() 
     214    wordtype* base() 
    212215    in 
    213216    { 
    214217        assert(data); 

  • tango/core/rt/compiler/ldc/object_.d

    old new  
    412412    /// Compares two instances for &lt;, ==, or &gt;. 
    413413    int compare(in void* p1, in void* p2) { return 0; } //throw new Exception("non comparable",__FILE__,__LINE__);  
    414414 
     415     /// Return alignment of type 
     416    size_t   talign() { return tsize(); } 
     417 
    415418    /// Returns size of the type. 
    416419    size_t tsize() { return 0; } 
    417420 

  • tango/core/rt/compiler/ldc/typeinfo/ti_void.d

    old new  
    2222        return *cast(byte *)p1 - *cast(byte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return void.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return void.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_wchar.d

    old new  
    2121        return *cast(wchar *)p1 - *cast(wchar *)p2; 
    2222    } 
    2323 
     24    override size_t talign() 
     25    { 
     26        return wchar.alignof; 
     27    } 
     28 
    2429    override size_t tsize() 
    2530    { 
    2631        return wchar.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_ptr.d

    old new  
    2525        return 0; 
    2626    } 
    2727 
     28    override size_t talign() 
     29    { 
     30        return (void*).alignof; 
     31    } 
     32 
    2833    override size_t tsize() 
    2934    { 
    3035        return (void*).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Afloat.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (float[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (float[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_double.d

    old new  
    4343        return _compare(*cast(double *)p1, *cast(double *)p2); 
    4444    } 
    4545 
     46    override size_t talign() 
     47    { 
     48        return double.alignof; 
     49    } 
     50 
    4651    override size_t tsize() 
    4752    { 
    4853        return double.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_delegate.d

    old new  
    1818        return *cast(dg *)p1 == *cast(dg *)p2; 
    1919    } 
    2020 
     21    override size_t talign() 
     22    { 
     23        return dg.alignof; 
     24    } 
     25 
    2126    override size_t tsize() 
    2227    { 
    2328        return dg.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Adouble.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (double[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (double[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_char.d

    old new  
    2020        return *cast(char *)p1 - *cast(char *)p2; 
    2121    } 
    2222 
     23    override size_t talign() 
     24    { 
     25        return char.alignof; 
     26    } 
     27 
    2328    override size_t tsize() 
    2429    { 
    2530        return char.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Acdouble.d

    old new  
    7575        return 0; 
    7676    } 
    7777 
     78    override size_t talign() 
     79    { 
     80        return (cdouble[]).alignof; 
     81    } 
     82 
    7883    override size_t tsize() 
    7984    { 
    8085        return (cdouble[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_uint.d

    old new  
    2626        return 0; 
    2727    } 
    2828 
     29    override size_t talign() 
     30    { 
     31        return uint.alignof; 
     32    } 
     33 
    2934    override size_t tsize() 
    3035    { 
    3136        return uint.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_AC.d

    old new  
    8282        return 0; 
    8383    } 
    8484 
     85    override size_t talign() 
     86    { 
     87        return (Object[]).alignof; 
     88    } 
     89 
    8590    override size_t tsize() 
    8691    { 
    8792        return (Object[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_ulong.d

    old new  
    3131        return 0; 
    3232    } 
    3333 
     34    override size_t talign() 
     35    { 
     36        return ulong.alignof; 
     37    } 
     38 
    3439    override size_t tsize() 
    3540    { 
    3641        return ulong.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_creal.d

    old new  
    4444        return _compare(*cast(creal *)p1, *cast(creal *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return creal.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return creal.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_ubyte.d

    old new  
    2222        return *cast(ubyte *)p1 - *cast(ubyte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return ubyte.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return ubyte.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Aint.d

    old new  
    4747        return 0; 
    4848    } 
    4949 
     50    override size_t talign() 
     51    { 
     52        return (int[]).alignof; 
     53    } 
     54 
    5055    override size_t tsize() 
    5156    { 
    5257        return (int[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_long.d

    old new  
    3131        return 0; 
    3232    } 
    3333 
     34    override size_t talign() 
     35    { 
     36        return long.alignof; 
     37    } 
     38 
    3439    override size_t tsize() 
    3540    { 
    3641        return long.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_short.d

    old new  
    2222        return *cast(short *)p1 - *cast(short *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return short.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return short.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Along.d

    old new  
    4848        return 0; 
    4949    } 
    5050 
     51    override size_t talign() 
     52    { 
     53        return (long[]).alignof; 
     54    } 
     55 
    5156    override size_t tsize() 
    5257    { 
    5358        return (long[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_byte.d

    old new  
    2222        return *cast(byte *)p1 - *cast(byte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return byte.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return byte.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_float.d

    old new  
    4242        return _compare(*cast(float *)p1, *cast(float *)p2); 
    4343    } 
    4444 
     45    override size_t talign() 
     46    { 
     47        return float.alignof; 
     48    } 
     49 
    4550    override size_t tsize() 
    4651    { 
    4752        return float.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_cfloat.d

    old new  
    4444        return _compare(*cast(cfloat *)p1, *cast(cfloat *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return cfloat.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return cfloat.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Acfloat.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (cfloat[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (cfloat[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_cdouble.d

    old new  
    4444        return _compare(*cast(cdouble *)p1, *cast(cdouble *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return cdouble.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return cdouble.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_dchar.d

    old new  
    2222        return *cast(dchar *)p1 - *cast(dchar *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return dchar.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return dchar.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_C.d

    old new  
    6262        return c; 
    6363    } 
    6464 
     65    override size_t talign() 
     66    { 
     67        return Object.alignof; 
     68    } 
     69 
    6570    override size_t tsize() 
    6671    { 
    6772        return Object.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_real.d

    old new  
    4343        return _compare(*cast(real *)p1, *cast(real *)p2); 
    4444    } 
    4545 
     46    override size_t talign() 
     47    { 
     48        return real.alignof; 
     49    } 
     50 
    4651    override size_t tsize() 
    4752    { 
    4853        return real.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_ushort.d

    old new  
    2222        return *cast(ushort *)p1 - *cast(ushort *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return ushort.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return ushort.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Areal.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (real[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (real[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Acreal.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (creal[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (creal[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Ag.d

    old new  
    4848        return 0; 
    4949    } 
    5050 
     51    override size_t talign() 
     52    { 
     53        return (byte[]).alignof; 
     54    } 
     55 
    5156    override size_t tsize() 
    5257    { 
    5358        return (byte[]).sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_int.d

    old new  
    2626        return 0; 
    2727    } 
    2828 
     29    override size_t talign() 
     30    { 
     31        return int.alignof; 
     32    } 
     33 
    2934    override size_t tsize() 
    3035    { 
    3136        return int.sizeof; 

  • tango/core/rt/compiler/ldc/typeinfo/ti_Ashort.d

    old new  
    4747        return 0; 
    4848    } 
    4949 
     50    override size_t talign() 
     51    { 
     52        return (short[]).alignof; 
     53    } 
     54 
    5055    override size_t tsize() 
    5156    { 
    5257        return (short[]).sizeof; 

  • tango/core/rt/compiler/dmd/rt/lifetime.d

    old new  
    3333    import tango.stdc.string : memcpy, memset, memcmp; 
    3434    import tango.stdc.stdarg; 
    3535    debug(PRINTF) import tango.stdc.stdio : printf; 
     36 
     37    alias void[] array_t; 
    3638} 
    3739 
    3840 
    …… 
    192194 * ti is the type of the resulting array, or pointer to element. 
    193195 * (For when the array is initialized to 0) 
    194196 */ 
    195 extern (C) ulong _d_newarrayT(TypeInfo ti, size_t length) 
     197extern(C) array_t _d_newarrayT(TypeInfo ti, size_t length) 
    196198{ 
    197199    void* p; 
    198     ulong result; 
     200    array_t result; 
    199201    auto size = ti.next.tsize();                // array element size 
    200202 
    201203    debug(PRINTF) printf("_d_newarrayT(length = x%x, size = %d)\n", length, size); 
    202204    if (length == 0 || size == 0) 
    203         result = 0; 
     205        result = array_t.init; 
    204206    else 
    205207    { 
    206208        version (D_InlineAsm_X86) 
    …… 
    213215                jc      Loverflow       ; 
    214216            } 
    215217        } 
     218        else version (D_InlineAsm_X86_64) 
     219            asm 
     220            { 
     221                mov     RAX,size        ; 
     222                mul     RAX,length      ; 
     223                mov     size,RAX        ; 
     224                jc      Loverflow       ; 
     225            } 
    216226        else 
    217227            size *= length; 
     228 
    218229        PointerMap pm; 
    219         version (D_HavePointerMap) { 
    220             pm = ti.next.pointermap(); 
    221         } 
     230        version (D_HavePointerMap)  pm = ti.next.pointermap(); 
     231 
    222232        p = gc_malloc(size + 1, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm); 
    223233        debug(PRINTF) printf(" p = %p\n", p); 
    224234        memset(p, 0, size); 
    225         result = cast(ulong)length + (cast(ulong)cast(uint)p << 32); 
     235        result = cast(array_t)p[0..length]; 
    226236    } 
    227237    return result; 
    228238 
    …… 
    233243/** 
    234244 * For when the array has a non-zero initializer. 
    235245 */ 
    236 extern (C) ulong _d_newarrayiT(TypeInfo ti, size_t length) 
     246extern(C) array_t _d_newarrayiT(TypeInfo ti, size_t length) 
    237247{ 
    238     ulong result; 
     248    array_t result; 
    239249    auto size = ti.next.tsize();                // array element size 
    240250 
    241251    debug(PRINTF) printf("_d_newarrayiT(length = %d, size = %d)\n", length, size); 
    242252 
    243253    if (length == 0 || size == 0) 
    244         result = 0; 
     254        result = array_t.init; 
    245255    else 
    246256    { 
    247257        auto initializer = ti.next.init(); 
    …… 
    257267                jc      Loverflow       ; 
    258268            } 
    259269        } 
     270        else version (D_InlineAsm_X86_64) 
     271            asm 
     272            { 
     273                mov     RAX,size        ; 
     274                mul     RAX,length      ; 
     275                mov     size,RAX        ; 
     276                jc      Loverflow       ; 
     277            } 
    260278        else 
    261279            size *= length; 
     280 
    262281        PointerMap pm; 
    263282        version (D_HavePointerMap) { 
    264283            pm = ti.next.pointermap(); 
    …… 
    284303            } 
    285304        } 
    286305        va_end(q); 
    287         result = cast(ulong)length + (cast(ulong)cast(uint)p << 32); 
     306        result = cast(array_t)p[0..length]; 
    288307    } 
    289308    return result; 
    290309 
    …… 
    295314/** 
    296315 * 
    297316 */ 
    298 extern (C) ulong _d_newarraymT(TypeInfo ti, int ndims, ...) 
     317extern(C) array_t _d_newarraymT(TypeInfo ti, int ndims, ...) 
    299318{ 
    300     ulong result; 
     319    array_t result; 
    301320 
    302321    debug(PRINTF) printf("_d_newarraymT(ndims = %d)\n", ndims); 
    303322    if (ndims == 0) 
    304         result = 0; 
     323        result = array_t.init; 
    305324    else 
    306     {   va_list q; 
    307         va_start!(int)(q, ndims); 
     325    { 
     326        va_list q; 
    308327 
    309         void[] foo(TypeInfo ti, size_t* pdim, int ndims) 
     328        version(X86) 
     329            va_start(q, ndims); 
     330        else version(X86_64) 
     331            va_start(q, __va_argsave); 
     332        else 
     333            static assert(false, "platform not supported"); 
     334 
     335        void[] foo(TypeInfo ti, va_list ap, int ndims) 
    310336        { 
    311             size_t dim = *pdim; 
     337            size_t dim; 
     338            va_arg(ap, dim); 
    312339            void[] p; 
    313340 
    314341            debug(PRINTF) printf("foo(ti = %p, ti.next = %p, dim = %d, ndims = %d\n", ti, ti.next, dim, ndims); 
    …… 
    320347            else 
    321348            { 
    322349                p = gc_malloc(dim * (void[]).sizeof + 1)[0 .. dim]; 
    323                 for (int i = 0; i < dim; i++) 
     350 
     351                version (X86) 
    324352                { 
    325                     (cast(void[]*)p.ptr)[i] = foo(ti.next, pdim + 1, ndims - 1); 
     353                    va_list ap2; 
     354                    va_copy(ap2, ap); 
    326355                } 
     356 
     357                for (size_t i = 0; i < dim; i++) 
     358                { 
     359                    version (X86_64) 
     360                    { 
     361                        __va_list argsave = *cast(__va_list*)ap; 
     362                        va_list ap2 = &argsave; 
    327363            } 
     364                    (cast(void[]*)p.ptr)[i] = foo(ti.next, ap2, ndims - 1); 
     365                } 
     366            } 
    328367            return p; 
    329368        } 
    330369 
    331         size_t* pdim = cast(size_t *)q; 
    332         result = cast(ulong)foo(ti, pdim, ndims); 
     370        result = cast(typeof(result))foo(ti, q, ndims); 
    333371        debug(PRINTF) printf("result = %llx\n", result); 
    334372 
    335373        version (none) 
    …… 
    348386/** 
    349387 * 
    350388 */ 
    351 extern (C) ulong _d_newarraymiT(TypeInfo ti, int ndims, ...) 
     389extern(C) array_t _d_newarraymiT(TypeInfo ti, size_t ndims, ...) 
    352390{ 
    353     ulong result; 
     391    array_t result; 
    354392 
    355393    debug(PRINTF) printf("_d_newarraymiT(ndims = %d)\n", ndims); 
    356394    if (ndims == 0) 
    357         result = 0; 
     395        result = array_t.init; 
    358396    else 
    359397    { 
    360398        va_list q; 
    361         va_start!(int)(q, ndims); 
    362399 
    363         void[] foo(TypeInfo ti, size_t* pdim, int ndims) 
     400        version(X86) 
     401            va_start(q, ndims); 
     402        else version(X86_64) 
     403            va_start(q, __va_argsave); 
     404        else 
     405            static assert(false, "platform not supported"); 
     406 
     407        void[] foo(TypeInfo ti, va_list ap, size_t ndims) 
    364408        { 
    365             size_t dim = *pdim; 
     409            size_t dim; 
     410            va_arg(ap, dim); 
    366411            void[] p; 
    367412 
    368413            if (ndims == 1) 
    …… 
    373418            else 
    374419            { 
    375420                p = gc_malloc(dim * (void[]).sizeof + 1)[0 .. dim]; 
    376                 for (int i = 0; i < dim; i++) 
     421 
     422                version (X86) 
    377423                { 
    378                     (cast(void[]*)p.ptr)[i] = foo(ti.next, pdim + 1, ndims - 1); 
     424                    va_list ap2; 
     425                    va_copy(ap2, ap); 
    379426                } 
     427 
     428                for (size_t i = 0; i < dim; i++) 
     429                { 
     430                    version (X86_64) 
     431                    { 
     432                        __va_list argsave = *cast(__va_list*)ap; 
     433                        va_list ap2 = &argsave; 
    380434            } 
     435                    (cast(void[]*)p.ptr)[i] = foo(ti.next, ap2, ndims - 1); 
     436                } 
     437            } 
     438 
    381439            return p; 
    382440        } 
    383441 
    384         size_t* pdim = cast(size_t *)q; 
    385         result = cast(ulong)foo(ti, pdim, ndims); 
     442        result = cast(typeof(result))foo(ti, q, ndims); 
    386443        debug(PRINTF) printf("result = %llx\n", result); 
    387444 
    388445        version (none) 
    …… 
    457514    { 
    458515        Interface *pi = **cast(Interface ***)p; 
    459516        Object o = cast(Object)(p - pi.offset); 
     517        debug(PRINTF)  printf("finalizing..."); 
    460518        rt_finalize(cast(void*)o); 
    461519    } 
    462520} 
    …… 
    467525 */ 
    468526extern (C) void _d_callfinalizer(void* p) 
    469527{ 
     528    debug(PRINTF)  printf("dcall finalizing..."); 
    470529    rt_finalize( p ); 
    471530} 
    472531 
    …… 
    490549    if (p) // not necessary if called from gc 
    491550    { 
    492551        if (det) 
     552        { 
     553            debug(PRINTF) printf("\t det=true, calling dispose\n"); 
    493554           (cast(Object)p).dispose(); 
     555        } 
     556        debug(PRINTF) printf("\tcasting to class info\n"); 
    494557 
    495558        ClassInfo** pc = cast(ClassInfo**)p; 
    496559 
     560        debug(PRINTF) printf("\tdereferencing pc: %lu\n", *pc); 
     561 
    497562        if (*pc) 
    498563        { 
    499564            ClassInfo c = **pc; 
    500565 
    501566            try 
    502567            { 
     568                debug(PRINTF) printf("\tdoing tests.. collecthandler is %lu\n", cast(void*)collectHandler); 
    503569                if (det || collectHandler is null || collectHandler(cast(Object)p)) 
    504570                { 
    505571                    do 
    …… 
    509575                            void delegate() dg; 
    510576                            dg.ptr = p; 
    511577                            dg.funcptr = cast(void function()) c.destructor; 
     578                            debug(PRINTF) printf("\tcalling dtor of %s\n", c.name.ptr); 
    512579                            dg(); // call destructor 
     580                            debug(PRINTF) printf("\tdtor done.\n"); 
    513581                        } 
    514582                        c = c.base; 
    515583                    } while (c); 
    …… 
    519587            } 
    520588            catch (Exception e) 
    521589            { 
     590                debug(PRINTF) printf("\tException while finalizing\n"); 
    522591                onFinalizeError(**pc, e); 
    523592            } 
    524593            finally 
    …… 
    527596            } 
    528597        } 
    529598    } 
     599    debug(PRINTF) printf("\tLeaving.\n"); 
    530600} 
    531601 
    532602 
    …… 
    753823    onOutOfMemoryError(); 
    754824} 
    755825 
     826/************************************** 
     827 * Extend an array by n elements. 
     828 * Caller must initialize that element. 
     829 */ 
     830version(X86_64) extern (C) byte[] _d_arrayappendcTX(TypeInfo ti, inout byte[] x, size_t n) 
     831{ 
     832    auto sizeelem = ti.next.tsize();            // array element size 
     833    auto info = gc_query(x.ptr); 
     834    auto length = x.length; 
     835    auto newlength = length + n; 
     836    auto newsize = newlength * sizeelem; 
    756837 
     838    assert(info.size == 0 || length * sizeelem <= info.size); 
     839 
     840    //printf("_d_arrayappendcTX(sizeelem = %d, ptr = %p, length = %d, cap = %d)\n", sizeelem, x.ptr, x.length, cap); 
     841 
     842    if (newsize >= info.size) 
     843    {   byte* newdata; 
     844 
     845        if (info.size >= PAGESIZE) 
     846        {   // Try to extend in-place 
     847            auto u = gc_extend(x.ptr, (newsize + 1) - info.size, (newsize + 1) - info.size); 
     848            if (u) 
     849            { 
     850                goto L1; 
     851            } 
     852        } 
     853 
     854        PointerMap pm; 
     855        version (D_HavePointerMap) { 
     856            pm = ti.next.pointermap(); 
     857        } 
     858 
     859        uint attr = !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0; 
     860        newdata = cast(byte *) gc_malloc(newCapacity(newlength, sizeelem) + 1, attr, pm); 
     861 
     862        memcpy(newdata, x.ptr, length * sizeelem); 
     863 
     864        (cast(void **)(&x))[1] = newdata; 
     865    } 
     866 
     867  L1: 
     868    *cast(size_t *)&x = newlength; 
     869    assert((cast(size_t)x.ptr & 15) == 0); 
     870    assert(gc_query(x.ptr).size > x.length * sizeelem); 
     871    return x; 
     872} 
     873 
     874 
    757875/** 
    758876 * Append y[] to array x[]. 
    759877 * size is size of each array element. 
    …… 
    11131231    byte[] b; 
    11141232    auto size = ti.next.tsize(); // array element size 
    11151233 
    1116     p = cast(byte[]*)(&n + 1); 
    1117  
    1118     for (i = 0; i < n; i++) 
     1234    version (X86) 
    11191235    { 
     1236        auto p = cast(byte[]*)(&n + 1); 
     1237        for (uint i = 0; i < n; i++) 
     1238        { 
    11201239        b = *p++; 
    11211240        length += b.length; 
    11221241    } 
     1242    } 
     1243    else version (X86_64) 
     1244    { 
     1245        __va_list argsave = __va_argsave.va; 
     1246        va_list ap; 
     1247        va_start(ap, __va_argsave); 
     1248        for (i = 0; i < n; i++) 
     1249        { 
     1250            b.length = 0; 
     1251            va_arg(ap, b); 
     1252            length += b.length; 
     1253        } 
     1254        va_end(ap); 
     1255    } 
     1256 
    11231257    if (!length) 
    11241258        return null; 
    11251259 
    …… 
    11281262        pm = ti.next.pointermap(); 
    11291263    } 
    11301264    a = gc_malloc(length * size, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm); 
     1265 
     1266    version (X86) 
     1267    { 
    11311268    p = cast(byte[]*)(&n + 1); 
    1132  
    1133     uint j = 0; 
     1269        size_t j = 0; 
    11341270    for (i = 0; i < n; i++) 
    11351271    { 
    11361272        b = *p++; 
    11371273        if (b.length) 
    11381274        { 
     1275                memcpy(a + j, b.ptr, b.length * sizee); 
     1276                j += b.length * size; 
     1277            } 
     1278        } 
     1279    } 
     1280    else version (X86_64) 
     1281    { 
     1282        va_list ap2 = &argsave; 
     1283        size_t j = 0; 
     1284        for (i = 0; i < n; i++) 
     1285        { 
     1286            b.length = 0; 
     1287            va_arg(ap2, b); 
     1288            if (b.length) 
     1289            { 
    11391290            memcpy(a + j, b.ptr, b.length * size); 
    11401291            j += b.length * size; 
    11411292        } 
    11421293    } 
     1294        va_end(ap2); 
     1295    } 
    11431296 
    11441297    byte[] result; 
    11451298    *cast(size_t *)&result = length;       // jam length 
    …… 
    11471300    return result; 
    11481301} 
    11491302 
     1303extern (C) void* _d_arrayliteralTX(TypeInfo ti, size_t length) 
     1304{ 
     1305    auto sizeelem = ti.next.tsize();            // array element size 
     1306    void* result; 
    11501307 
     1308    //printf("_d_arrayliteralTX(sizeelem = %d, length = %d)\n", sizeelem, length); 
     1309    if (length == 0 || sizeelem == 0) 
     1310        result = null; 
     1311    else 
     1312    { 
     1313        PointerMap pm; 
     1314        version (D_HavePointerMap) { 
     1315            pm = ti.next.pointermap(); 
     1316        } 
     1317        result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm); 
     1318    } 
     1319    return result; 
     1320} 
     1321 
    11511322/** 
    11521323 * 
    11531324 */ 
    1154 extern (C) void* _d_arrayliteralT(TypeInfo ti, size_t length, ...) 
     1325version (X86) extern (C) void* _d_arrayliteralT(TypeInfo ti, size_t length, ...) 
    11551326{ 
    11561327    auto sizeelem = ti.next.tsize();            // array element size 
    11571328    void* result; 
    …… 
    11671338        } 
    11681339        result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? BlkAttr.NO_SCAN : 0, pm); 
    11691340 
     1341        version(X86) 
     1342        { 
    11701343        va_list q; 
    11711344        va_start!(size_t)(q, length); 
    11721345 
    …… 
    11871360 
    11881361        va_end(q); 
    11891362    } 
     1363        else version(X86_64) 
     1364        { 
     1365            va_list q; 
     1366            va_start(q, __va_argsave); 
     1367            for (size_t i = 0; i < length; i++) 
     1368            { 
     1369                va_arg(q, ti.next, result + i * sizeelem); 
     1370            } 
     1371            va_end(q); 
     1372        } 
     1373    } 
    11901374    return result; 
    11911375} 
    11921376 
    …… 
    12041388/** 
    12051389 * 
    12061390 */ 
    1207 extern (C) long _adDupT(TypeInfo ti, Array2 a) 
     1391extern (C) array_t _adDupT(TypeInfo ti, Array2 a) 
    12081392out (result) 
    12091393{ 
    12101394    auto sizeelem = ti.next.tsize();            // array element size 
    …… 
    12261410        r.length = a.length; 
    12271411        memcpy(r.ptr, a.ptr, size); 
    12281412    } 
    1229     return *cast(long*)(&r); 
     1413    return *cast(array_t*)(&r); 
    12301414} 
    12311415 
    12321416 

  • tango/core/rt/compiler/dmd/rt/trace.d

    old new  
    787787     *  dw      length 
    788788     *  ascii   string 
    789789     */ 
    790  
    791     version (OSX) { // 16 byte align stack 
    792         asm { 
    793             naked               ; 
     790  version (OSX) 
     791  { // 16 byte align stack 
     792   version (D_InlineAsm_X86) 
     793    asm 
     794    {   naked                           ; 
    794795            pushad              ; 
    795796            mov ECX,8*4[ESP]        ; 
    796797            xor EAX,EAX         ; 
    …… 
    814815            popad               ; 
    815816            ret             ; 
    816817        } 
    817     } else { 
    818         asm { 
    819             naked                           ; 
     818      else version (D_InlineAsm_X86_64) 
     819            static assert(0); 
     820      else 
     821            static assert(0); 
     822  } 
     823  else 
     824  { 
     825   version (D_InlineAsm_X86) 
     826    asm 
     827    {   naked                           ; 
    820828            pushad                          ; 
    821829            mov     ECX,8*4[ESP]            ; 
    822830            xor     EAX,EAX                 ; 
    …… 
    839847            popad                           ; 
    840848            ret                             ; 
    841849        } 
     850    else version (D_InlineAsm_X86_64) 
     851    asm 
     852    {   naked                           ; 
     853        push    RAX                     ; 
     854        push    RCX                     ; 
     855        push    RDX                     ; 
     856        push    RSI                     ; 
     857        push    RDI                     ; 
     858        push    R8                      ; 
     859        push    R9                      ; 
     860        push    R10                     ; 
     861        push    R11                     ; 
     862        mov     RCX,9*8[RSP]            ; 
     863        xor     RAX,RAX                 ; 
     864        mov     AL,[RCX]                ; 
     865        cmp     AL,0xFF                 ; 
     866        jne     L1                      ; 
     867        cmp     byte ptr 1[RCX],0       ; 
     868        jne     L1                      ; 
     869        mov     AX,2[RCX]               ; 
     870        add     9*8[RSP],3              ; 
     871        add     RCX,3                   ; 
     872    L1: inc     RAX                     ; 
     873        inc     RCX                     ; 
     874        add     9*8[RSP],RAX            ; 
     875        dec     RAX                     ; 
     876        push    RCX                     ; 
     877        push    RAX                     ; 
     878        call    trace_pro               ; 
     879        add     RSP,16                  ; 
     880        pop     R11                     ; 
     881        pop     R10                     ; 
     882        pop     R8                      ; 
     883        pop     R9                      ; 
     884        pop     RDI                     ; 
     885        pop     RSI                     ; 
     886        pop     RDX                     ; 
     887        pop     RCX                     ; 
     888        pop     RAX                     ; 
     889        ret                             ; 
    842890    } 
     891    else 
     892            static assert(0); 
    843893} 
     894} 
    844895 
    845896///////////////////////////////////////////// 
    846897// Function called by trace code in function epilog. 
    …… 
    906957        } 
    907958    } 
    908959} 
     960else version (D_InlineAsm_X86_64) 
     961{ 
     962    extern (D) 
     963    { 
     964        void QueryPerformanceCounter(timer_t* ctr) 
     965        { 
     966            asm 
     967            { 
     968                naked                   ; 
     969                rdtsc                   ; 
     970                mov   [RDI],EAX         ; 
     971                mov   4[RDI],EDX        ; 
     972                ret                     ; 
     973            } 
     974        } 
     975 
     976        void QueryPerformanceFrequency(timer_t* freq) 
     977        { 
     978            *freq = 3579545; 
     979        } 
     980    } 
     981} 
    909982else 
    910983{ 
    911984    static assert(0); 

  • tango/core/rt/compiler/dmd/rt/memory.d

    old new  
    109109            ret; 
    110110        } 
    111111    } 
     112    else version( D_InlineAsm_X86_64 ) 
     113    { 
     114        asm 
     115        { 
     116            naked; 
     117            mov RAX, RSP; 
     118            ret; 
     119        } 
     120    } 
    112121    else 
    113122    { 
    114123            static assert( false, "Architecture not supported." ); 

  • tango/core/rt/compiler/dmd/rt/dmain2.d

    old new  
    112112    if (result) 
    113113        return result; 
    114114     
     115    printf("Running critical init.\n"); 
    115116    _d_criticalInit(); 
    116117 
    117118    try 
    118119    { 
     120        printf("Running gc_init.\n"); 
    119121        gc_init(); 
    120122        version (Win32) 
    121123            _minit(); 
     124        printf("Running module ctors.\n"); 
    122125        _moduleCtor(); 
    123126        return result = true; 
    124127    } 
    …… 
    138141    { 
    139142        console("error while executing module initializers\n"); 
    140143    } 
     144    printf("Running critical term.\n"); 
    141145    _d_criticalTerm(); 
    142146    return result = false; 
    143147} 
    …… 
    305309        { 
    306310            try 
    307311            { 
     312                printf("Running dg.\n"); 
    308313                dg(); 
    309314            } 
    310315            catch (Exception e) 
    311316            { 
     317                printf("Exception happened.\n"); 
    312318                e.writeOut(delegate void(char[]s){ console(s); }); 
    313319                result = EXIT_FAILURE; 
    314320            } 
    315321            catch (Object o) 
    316322            { 
     323                printf("Object happened.\n"); 
    317324                //fprintf(stderr, "%.*s\n", o.toString()); 
    318325                console (o.toString)("\n"); 
    319326                result = EXIT_FAILURE; 
    …… 
    341348 
    342349    void runAll() 
    343350    { 
     351        printf("Running init.\n"); 
    344352        rt_init(); 
     353        printf("Running runModuleUnitTests.\n"); 
    345354        if (runModuleUnitTests()) 
     355        { 
     356            printf("Running main.\n"); 
    346357            tryExec(&runMain); 
     358        } 
     359 
     360        printf("Running Term.\n"); 
    347361        rt_term(); 
    348362    } 
    349363 

  • tango/core/rt/compiler/dmd/rt/cover.d

    old new  
    3434    struct BitArray 
    3535    { 
    3636        size_t  len; 
    37         uint*  ptr; 
     37        size_t* ptr; 
    3838 
    3939        bool opIndex( size_t i ) 
    4040        in 

  • tango/core/rt/compiler/dmd/rt/aaA.d

    old new  
    6969 * Although DMD will return types of Array in registers, 
    7070 * gcc will not, so we instead use a 'long'. 
    7171 */ 
    72 alias long ArrayRet_t; 
     72alias void[] ArrayRet_t; 
    7373 
    7474struct Array 
    7575{ 
    …… 
    110110 
    111111size_t aligntsize(size_t tsize) 
    112112{ 
    113     // Is pointer alignment on the x64 4 bytes or 8? 
     113    version (X86_64) 
     114        // Size of key needed to align value on 16 bytes 
     115        return (tsize + 15) & ~(15); 
     116    else 
    114117    return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1); 
    115118} 
    116119 
    …… 
    238241 */ 
    239242 
    240243void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, ...) 
     244{ 
     245    return _aaGetX(aa, keyti, valuesize, cast(void *)(&valuesize + 1)); 
     246} 
     247 
     248void* _aaGetX(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey) 
    241249in 
    242250{ 
    243251    assert(aa); 
    …… 
    251259} 
    252260body 
    253261{ 
    254     auto pkey = cast(void *)(&valuesize + 1); 
    255262    size_t i; 
    256263    aaA *e; 
    257264    auto keysize = aligntsize(keyti.tsize()); 
    258265 
    259266    if (!aa.a) 
    260267        aa.a = new BB(); 
     268 
    261269    aa.a.keyti = keyti; 
    262270 
    263271    if (!aa.a.b.length) 
    …… 
    269277    } 
    270278 
    271279    auto key_hash = keyti.getHash(pkey); 
     280 
    272281    //printf("hash = %d\n", key_hash); 
     282 
    273283    i = key_hash % aa.a.b.length; 
    274284    auto pe = &aa.a.b[i]; 
     285 
    275286    while ((e = *pe) !is null) 
    276287    { 
    277288        if (key_hash == e.hash) 
    …… 
    312323 
    313324void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, ...) 
    314325{ 
     326    return _aaGetRvalueX(aa, keyti, valuesize, cast(void *)(&valuesize + 1)); 
     327} 
     328 
     329void* _aaGetRvalueX(AA aa, TypeInfo keyti, size_t valuesize, void* pkey) 
     330{ 
    315331    //printf("_aaGetRvalue(valuesize = %u)\n", valuesize); 
    316332    if (!aa.a) 
    317333        return null; 
    318334 
    319     auto pkey = cast(void *)(&valuesize + 1); 
    320335    auto keysize = aligntsize(keyti.tsize()); 
    321336    auto len = aa.a.b.length; 
    322337 
    …… 
    351366 */ 
    352367 
    353368void* _aaIn(AA aa, TypeInfo keyti, ...) 
     369{ 
     370    return _aaInX(aa, keyti, cast(void *)(&keyti + 1)); 
     371} 
     372 
     373void* _aaInX(AA aa, TypeInfo keyti, void* pkey) 
    354374in 
    355375{ 
    356376} 
    …… 
    362382{ 
    363383    if (aa.a) 
    364384    { 
    365         auto pkey = cast(void *)(&keyti + 1); 
    366  
    367385        //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.a.length, cast(uint)aa.a.ptr); 
    368386        auto len = aa.a.b.length; 
    369387 
    …… 
    399417 
    400418void _aaDel(AA aa, TypeInfo keyti, ...) 
    401419{ 
    402     auto pkey = cast(void *)(&keyti + 1); 
     420    return _aaDelX(aa, keyti, cast(void *)(&keyti + 1)); 
     421} 
     422 
     423void _aaDelX(AA aa, TypeInfo keyti, void* pkey) 
     424{ 
    403425    aaA *e; 
    404426 
    405427    if (aa.a && aa.a.b.length) 
    …… 
    673695 
    674696    auto len = _aaLen(aa); 
    675697    if (!len) 
    676         return 0; 
     698        return null; 
    677699    res = (cast(byte*) gc_malloc(len * keysize, 
    678700                                 !(aa.a.keyti.flags() & 1) ? BlkAttr.NO_SCAN : 0))[0 .. len * keysize]; 
    679701    resi = 0; 
    …… 
    801823    return result; 
    802824} 
    803825 
     826extern (C) BB* _d_assocarrayliteralTX(TypeInfo_AssociativeArray ti, void[] keys, void[] values) 
     827{ 
     828    auto valueti = ti.next; 
     829    auto valuesize = valueti.tsize();           // value size 
     830    auto keyti = ti.key; 
     831    auto keysize = keyti.tsize();               // key size 
     832    auto length = keys.length; 
     833    BB* result; 
    804834 
     835    //printf("_d_assocarrayliteralT(keysize = %d, valuesize = %d, length = %d)\n", keysize, valuesize, length); 
     836    //printf("tivalue = %.*s\n", ti.next.classinfo.name); 
     837    assert(length == values.length); 
     838    if (length == 0 || valuesize == 0 || keysize == 0) 
     839    { 
     840        ; 
     841    } 
     842    else 
     843    { 
     844        result = new BB(); 
     845 
     846        size_t i; 
     847        for (i = 0; i < prime_list.length - 1; i++) 
     848        { 
     849            if (length <= prime_list[i]) 
     850                break; 
     851        } 
     852        auto len = prime_list[i]; 
     853        result.b = new aaA*[len]; 
     854 
     855        size_t keytsize = aligntsize(keysize); 
     856 
     857        for (size_t j = 0; j < length; j++) 
     858        {   auto pkey = keys.ptr + j * keysize; 
     859            auto pvalue = values.ptr + j * valuesize; 
     860            aaA* e; 
     861 
     862            auto key_hash = keyti.getHash(pkey); 
     863            //printf("hash = %d\n", key_hash); 
     864            i = key_hash % len; 
     865            auto pe = &result.b[i]; 
     866            while (1) 
     867            { 
     868                e = *pe; 
     869                if (!e) 
     870                { 
     871                    // Not found, create new elem 
     872                    //printf("create new one\n"); 
     873                    e = cast(aaA *) cast(void*) new void[aaA.sizeof + keytsize + valuesize]; 
     874                    memcpy(e + 1, pkey, keysize); 
     875                    e.hash = key_hash; 
     876                    *pe = e; 
     877                    result.nodes++; 
     878                    break; 
     879                } 
     880                if (key_hash == e.hash) 
     881                { 
     882                    auto c = keyti.compare(pkey, e + 1); 
     883                    if (c == 0) 
     884                        break; 
     885                    pe = (c < 0) ? &e.left : &e.right; 
     886                } 
     887                else 
     888                    pe = (key_hash < e.hash) ? &e.left : &e.right; 
     889            } 
     890            memcpy(cast(void *)(e + 1) + keytsize, pvalue, valuesize); 
     891        } 
     892    } 
     893    return result; 
     894} 
     895 
    805896/*********************************** 
    806897 * Construct an associative array of type ti from 
    807898 * length pairs of key/value pairs. 
    808899 */ 
    809900 
    810 extern (C) 
    811 BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...) 
     901extern (C) BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...) 
    812902{ 
    813903    auto valuesize = ti.next.tsize();           // value size 
    814904    auto keyti = ti.key; 
    …… 
    824914    else 
    825915    { 
    826916        va_list q; 
    827         va_start!(size_t)(q, length); 
     917        version(X86_64) va_start(q, __va_argsave); else va_start!(size_t)(q, length); 
    828918 
    829919        result = new BB(); 
    830920        result.keyti = keyti; 

  • tango/core/rt/compiler/dmd/rt/cast_.d

    old new  
    8282 
    8383Object _d_dynamic_cast(Object o, ClassInfo c) 
    8484{   ClassInfo oc; 
    85     size_t offset = 0; 
     85    uint offset = 0; 
    8686 
    8787    //printf("_d_dynamic_cast(o = %p, c = '%.*s')\n", o, c.name); 
    8888 
    …… 
    101101    return o; 
    102102} 
    103103 
    104 int _d_isbaseof2(ClassInfo oc, ClassInfo c, ref size_t offset) 
     104int _d_isbaseof2(ClassInfo oc, ClassInfo c, ref uint offset) 
    105105{   int i; 
    106106 
    107107    if (oc is c) 

  • tango/core/rt/compiler/dmd/rt/memset.d

    old new  
    4141    return pstart; 
    4242} 
    4343 
     44 
    4445int *_memset32(int *p, int value, size_t count) 
    4546{ 
    46 version (X86) 
     47version (D_InlineAsm_X86) 
    4748{ 
    4849    asm 
    4950    { 
    …… 
    118119    } 
    119120    return pstart; 
    120121} 
     122 
     123float *_memsetFloat(float *p, float value, size_t count) 
     124{ 
     125    float *pstart = p; 
     126    float *ptop; 
     127 
     128    for (ptop = &p[count]; p < ptop; p++) 
     129        *p = value; 
     130    return pstart; 
     131} 
     132 
     133double *_memsetDouble(double *p, double value, size_t count) 
     134{ 
     135    double *pstart = p; 
     136    double *ptop; 
     137 
     138    for (ptop = &p[count]; p < ptop; p++) 
     139        *p = value; 
     140    return pstart; 
     141} 

  • tango/core/rt/compiler/dmd/rt/alloca.d

    old new  
    2727 *      EAX     allocated data, null if stack overflows 
    2828 */ 
    2929 
     30 
    3031extern (C) void* __alloca(int nbytes) 
    3132{ 
     33  version (D_InlineAsm_X86) 
     34  { 
    3235    asm 
    3336    { 
    3437        naked                   ; 
    …… 
    3740        push    EBX             ; 
    3841        push    EDI             ; 
    3942        push    ESI             ; 
     43    } 
     44 
     45    version (OSX) 
     46    { 
     47    asm 
     48    { 
     49        add     EAX,15          ; 
     50        and     EAX,0xFFFFFFF0  ; // round up to 16 byte boundary 
     51    } 
     52    } 
     53    else 
     54    { 
     55    asm 
     56    { 
    4057        add     EAX,3           ; 
    4158        and     EAX,0xFFFFFFFC  ; // round up to dword 
     59    } 
     60    } 
     61 
     62    asm 
     63    { 
    4264        jnz     Abegin          ; 
    4365        mov     EAX,4           ; // allow zero bytes allocation, 0 rounded to dword is 4.. 
    4466    Abegin: 
    …… 
    108130        ret                     ; 
    109131    } 
    110132} 
     133  else version (D_InlineAsm_X86_64) 
     134  { 
     135    asm 
     136    { 
     137        naked                   ; 
     138        mov     RDX,RCX         ; 
     139        mov     RAX,RDI         ; // get nbytes 
     140        add     RAX,15          ; 
     141        and     AL,0xF0         ; // round up to 16 byte boundary 
     142        test    RAX,RAX         ; 
     143        jnz     Abegin          ; 
     144        mov     RAX,16          ; // allow zero bytes allocation 
     145    Abegin: 
     146        mov     RSI,RAX         ; // RSI = nbytes 
     147        neg     RAX             ; 
     148        add     RAX,RSP         ; // RAX is now what the new RSP will be. 
     149        jae     Aoverflow       ; 
     150    } 
     151    version (Win64) 
     152    { 
     153    asm 
     154    { 
     155        // We need to be careful about the guard page 
     156        // Thus, for every 4k page, touch it to cause the OS to load it in. 
     157        mov     RCX,RAX         ; // RCX is new location for stack 
     158        mov     RBX,RSI         ; // RBX is size to "grow" stack 
     159    L1: 
     160        test    [RCX+RBX],RBX   ; // bring in page 
     161        sub     RBX,0x1000      ; // next 4K page down 
     162        jae     L1              ; // if more pages 
     163        test    [RCX],RBX       ; // bring in last page 
     164    } 
     165    } 
     166    version (Unix) 
     167    { 
     168    asm 
     169    { 
     170        cmp     RAX,_pastdata   ; 
     171        jbe     Aoverflow       ; // Unlikely - ~2 Gbytes under UNIX 
     172    } 
     173    } 
     174    asm 
     175    { 
     176        // Copy down to [RSP] the temps on the stack. 
     177        // The number of temps is (RBP - RSP - locals). 
     178        mov     RCX,RBP         ; 
     179        sub     RCX,RSP         ; 
     180        sub     RCX,[RDX]       ; // RCX = number of temps (bytes) to move. 
     181        add     [RDX],RSI       ; // adjust locals by nbytes for next call to alloca() 
     182        mov     RSP,RAX         ; // Set up new stack pointer. 
     183        add     RAX,RCX         ; // Return value = RSP + temps. 
     184        mov     RDI,RSP         ; // Destination of copy of temps. 
     185        add     RSI,RSP         ; // Source of copy. 
     186        shr     RCX,3           ; // RCX to count of qwords in temps 
     187        rep                     ; 
     188        movsq                   ; 
     189        jmp     done            ; 
     190 
     191    Aoverflow: 
     192        // Overflowed the stack.  Return null 
     193        xor     RAX,RAX         ; 
     194 
     195    done: 
     196        ret                     ; 
     197    } 
     198  } 
     199  else 
     200        static assert(0); 
     201} 

  • tango/core/rt/compiler/dmd/object_.d

    old new  
    331331    { 
    332332        foreach (m; ModuleInfo) 
    333333        { 
     334            if (!m) 
     335                continue; 
     336 
    334337            //writefln("module %s, %d", m.name, m.localClasses.length); 
    335338            foreach (c; m.localClasses) 
    336339            { 
    …… 
    416419 
    417420    /// Compares two instances for &lt;, ==, or &gt;. 
    418421    int compare(in void* p1, in void* p2) { return 0; } // throw new Exception("non comparable",__FILE__,__LINE__); 
    419  
     422    /// Return alignment of type 
     423    size_t talign() { return tsize(); } 
    420424    /// Returns size of the type. 
    421425    size_t tsize() { return 0; } 
    422426 
    …… 
    473477 
    474478    /// Get type information on the contents of the type; null if not available 
    475479    OffsetTypeInfo[] offTi() { return null; } 
     480 
     481 
     482     /** Return internal info on arguments fitting into 8byte. 
     483       * See X86-64 ABI 3.2.3 
     484     */ 
     485    version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     486    { 
     487        arg1 = this; 
     488        return 0; 
    476489} 
     490} 
    477491 
    478492class TypeInfo_Typedef : TypeInfo 
    479493{ 
    …… 
    499513    override PointerMap pointermap() { return base.pointermap(); } 
    500514    override void[] init() { return m_init.length ? m_init : base.init(); } 
    501515 
     516    size_t talign() { return base.talign(); } 
     517 
     518    version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     519    {    
     520        return base.argTypes(arg1, arg2); 
     521    } 
     522 
    502523    TypeInfo base; 
    503524    char[] name; 
    504525    void[] m_init; 
    …… 
    636657 
    637658    override uint flags() { return 1; } 
    638659 
     660    size_t talign() 
     661    { 
     662        return (void[]).alignof; 
     663    } 
     664 
     665    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     666    {   //arg1 = typeid(size_t); 
     667        //arg2 = typeid(void*); 
     668        return 0; 
     669    } 
     670 
    639671    override PointerMap pointermap() 
    640672    { 
    641673        //return static mask for arrays 
    …… 
    750782 
    751783    TypeInfo value; 
    752784    size_t   len; 
     785 
     786    size_t talign() 
     787    { 
     788        return value.talign(); 
    753789} 
    754790 
     791    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     792    { 
     793        arg1 = typeid(void*); 
     794        return 0; 
     795    } 
     796 
     797} 
     798 
    755799class TypeInfo_AssociativeArray : TypeInfo 
    756800{ 
    757801    override char[] toString() 
    …… 
    818862 
    819863    TypeInfo value; 
    820864    TypeInfo key; 
     865 
     866    size_t talign() 
     867    { 
     868        return (char[int]).alignof; 
    821869} 
    822870 
     871    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     872    { 
     873        arg1 = typeid(void*); 
     874        return 0; 
     875    } 
     876} 
     877 
    823878class TypeInfo_Function : TypeInfo 
    824879{ 
    825880    override char[] toString() 
    …… 
    902957    } 
    903958 
    904959    TypeInfo next; 
     960 
     961    size_t talign() 
     962    { 
     963        alias int delegate() dg; 
     964        return dg.alignof; 
    905965} 
    906966 
     967    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     968    {   //arg1 = typeid(void*); 
     969        //arg2 = typeid(void*); 
     970        return 0; 
     971    } 
     972 
     973} 
     974 
    907975class TypeInfo_Class : TypeInfo 
    908976{ 
    909977    override char[] toString() { return info.name; } 
    …… 
    11141182 
    11151183    override uint flags() { return m_flags; } 
    11161184 
     1185    size_t talign() { return m_align; } 
     1186 
     1187 
    11171188    char[] name; 
    11181189    void[] m_init;      // initializer; init.ptr == null if 0 initialize 
    11191190 
    …… 
    11241195    char[] function()   xtoString; 
    11251196 
    11261197    uint m_flags; 
     1198    uint m_align; 
    11271199 
    11281200    version (D_HavePointerMap) { 
    11291201        PointerMap m_pointermap; 
    11301202 
    11311203        override PointerMap pointermap() { return m_pointermap; } 
    11321204    } 
     1205 
     1206    version (X86_64) 
     1207    { 
     1208        int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     1209        { 
     1210            arg1 = m_arg1; 
     1211            arg2 = m_arg2; 
     1212            return 0; 
    11331213} 
     1214        TypeInfo m_arg1; 
     1215        TypeInfo m_arg2; 
     1216    } 
     1217} 
    11341218 
    11351219class TypeInfo_Tuple : TypeInfo 
    11361220{ 
    …… 
    11971281    { 
    11981282        assert(0); 
    11991283    } 
     1284 
     1285    version (X86_64) int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     1286    { 
     1287        assert(0); 
    12001288} 
     1289} 
    12011290 
    12021291 
    12031292//////////////////////////////////////////////////////////////////////////////// 
    …… 
    14761565        {   _moduleinfo_array[len] = mr.mod; 
    14771566            len++; 
    14781567        } 
     1568 
     1569        debug(PRINTF) foreach (m; _moduleinfo_array) 
     1570        { 
     1571            //printf("\t%p\n", m); 
     1572            printf("\t%.*s\n", m.name.length,m.name.ptr); 
    14791573    } 
    14801574 
     1575    } 
     1576 
    14811577    version( freebsd ) 
    14821578    { 
    14831579        int len = 0; 
    …… 
    15521648        debug(PRINTF) printf("\tmodule[%d] = '%p'\n", i, m); 
    15531649        if (!m) 
    15541650            continue; 
    1555         debug(PRINTF) printf("\tmodule[%d] = '%.*s'\n", i, m.name); 
     1651        debug(PRINTF) printf("\tmodule[%d].name = '%s'\n", i, m.name); 
    15561652        if (m.flags & MIctordone) 
    15571653            continue; 
    15581654        debug(PRINTF) printf("\tmodule[%d] = '%.*s', m = x%x\n", i, m.name, m); 

  • tango/core/rt/compiler/dmd/std/intrinsic.d

    old new  
    2525 *  The bit number of the first bit set. 
    2626 *  The return value is undefined if v is zero. 
    2727 */ 
    28 int bsf( uint v ); 
     28int bsf( size_t v ); 
    2929 
    3030 
    3131/** 
    …… 
    133133array = [0]:x2, [1]:x100 
    134134</pre> 
    135135 */ 
     136 
    136137int bts( size_t* p, size_t bitnum ); 
    137138 
    138  
    139139/** 
    140140 * Swaps bytes in a 4 byte uint end-to-end, i.e. byte 0 becomes 
    141141 * byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3 

  • tango/core/rt/compiler/dmd/typeinfo/ti_void.d

    old new  
    2222        return *cast(byte *)p1 - *cast(byte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return void.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return void.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_wchar.d

    old new  
    2121        return *cast(wchar *)p1 - *cast(wchar *)p2; 
    2222    } 
    2323 
     24    override size_t talign() 
     25    { 
     26        return wchar.alignof; 
     27    } 
     28 
    2429    override size_t tsize() 
    2530    { 
    2631        return wchar.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_ptr.d

    old new  
    2525        return 0; 
    2626    } 
    2727 
     28    override size_t talign() 
     29    { 
     30        return (void*).alignof; 
     31    } 
     32 
    2833    override size_t tsize() 
    2934    { 
    3035        return (void*).sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Afloat.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (float[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (float[]).sizeof; 
    …… 
    9095    { 
    9196        return typeid(float); 
    9297    } 
     98 
     99    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     100    { 
     101        return 0; 
    93102} 
     103} 
    94104 
    95105// ifloat[] 
    96106 

  • tango/core/rt/compiler/dmd/typeinfo/ti_double.d

    old new  
    4343        return _compare(*cast(double *)p1, *cast(double *)p2); 
    4444    } 
    4545 
     46    override size_t talign() 
     47    { 
     48        return double.alignof; 
     49    } 
     50 
    4651    override size_t tsize() 
    4752    { 
    4853        return double.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_delegate.d

    old new  
    1818        return *cast(dg *)p1 == *cast(dg *)p2; 
    1919    } 
    2020 
     21    override size_t talign() 
     22    { 
     23        return dg.alignof; 
     24    } 
     25 
    2126    override size_t tsize() 
    2227    { 
    2328        return dg.sizeof; 
    …… 
    3641    { 
    3742        return 1; 
    3843    } 
     44 
     45    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     46    { 
     47        arg1 = typeid(void*); 
     48        arg2 = typeid(void*); 
     49        return 0; 
    3950} 
     51} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Adouble.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (double[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (double[]).sizeof; 
    …… 
    9095    { 
    9196        return typeid(double); 
    9297    } 
     98 
     99    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     100    { 
     101        return 0; 
    93102} 
     103} 
    94104 
    95105// idouble[] 
    96106 

  • tango/core/rt/compiler/dmd/typeinfo/ti_char.d

    old new  
    2020        return *cast(char *)p1 - *cast(char *)p2; 
    2121    } 
    2222 
     23    override size_t talign() 
     24    { 
     25        return char.alignof; 
     26    } 
     27 
    2328    override size_t tsize() 
    2429    { 
    2530        return char.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Acdouble.d

    old new  
    7575        return 0; 
    7676    } 
    7777 
     78    override size_t talign() 
     79    { 
     80        return (cdouble[]).alignof; 
     81    } 
     82 
    7883    override size_t tsize() 
    7984    { 
    8085        return (cdouble[]).sizeof; 
    …… 
    8994    { 
    9095        return typeid(cdouble); 
    9196    } 
     97 
     98    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     99    { 
     100        return 0; 
    92101} 
     102} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_uint.d

    old new  
    2626        return 0; 
    2727    } 
    2828 
     29    override size_t talign() 
     30    { 
     31        return uint.alignof; 
     32    } 
     33 
    2934    override size_t tsize() 
    3035    { 
    3136        return uint.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_AC.d

    old new  
    8282        return 0; 
    8383    } 
    8484 
     85    override size_t talign() 
     86    { 
     87        return (Object[]).alignof; 
     88    } 
     89 
    8590    override size_t tsize() 
    8691    { 
    8792        return (Object[]).sizeof; 
    …… 
    96101    { 
    97102        return typeid(Object); 
    98103    } 
     104 
     105    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     106    { 
     107        return 0; 
    99108} 
     109} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_ulong.d

    old new  
    3131        return 0; 
    3232    } 
    3333 
     34    override size_t talign() 
     35    { 
     36        return ulong.alignof; 
     37    } 
     38 
    3439    override size_t tsize() 
    3540    { 
    3641        return ulong.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_creal.d

    old new  
    4444        return _compare(*cast(creal *)p1, *cast(creal *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return creal.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return creal.sizeof; 
    …… 
    6368 
    6469        return (cast(creal *)&r)[0 .. 1]; 
    6570    } 
     71 
     72    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     73    { 
     74        arg1 = typeid(real); 
     75        arg2 = typeid(real); 
     76        return 0; 
    6677} 
     78} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_ubyte.d

    old new  
    2222        return *cast(ubyte *)p1 - *cast(ubyte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return ubyte.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return ubyte.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Aint.d

    old new  
    4747        return 0; 
    4848    } 
    4949 
     50    override size_t talign() 
     51    { 
     52        return (int[]).alignof; 
     53    } 
     54 
    5055    override size_t tsize() 
    5156    { 
    5257        return (int[]).sizeof; 
    …… 
    6166    { 
    6267        return typeid(int); 
    6368    } 
     69 
     70    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     71    { 
     72        return 0; 
    6473} 
     74} 
    6575 
    6676unittest 
    6777{ 

  • tango/core/rt/compiler/dmd/typeinfo/ti_long.d

    old new  
    3131        return 0; 
    3232    } 
    3333 
     34    override size_t talign() 
     35    { 
     36        return long.alignof; 
     37    } 
     38 
    3439    override size_t tsize() 
    3540    { 
    3641        return long.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_short.d

    old new  
    2222        return *cast(short *)p1 - *cast(short *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return short.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return short.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Along.d

    old new  
    4848        return 0; 
    4949    } 
    5050 
     51    override size_t talign() 
     52    { 
     53        return (long[]).alignof; 
     54    } 
     55 
    5156    override size_t tsize() 
    5257    { 
    5358        return (long[]).sizeof; 
    …… 
    6267    { 
    6368        return typeid(long); 
    6469    } 
     70 
     71    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     72    { 
     73        return 0; 
    6574} 
     75} 
    6676 
    6777 
    6878// ulong[] 

  • tango/core/rt/compiler/dmd/typeinfo/ti_byte.d

    old new  
    2222        return *cast(byte *)p1 - *cast(byte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return byte.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return byte.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_float.d

    old new  
    4242        return _compare(*cast(float *)p1, *cast(float *)p2); 
    4343    } 
    4444 
     45    override size_t talign() 
     46    { 
     47        return float.alignof; 
     48    } 
     49 
    4550    override size_t tsize() 
    4651    { 
    4752        return float.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_cfloat.d

    old new  
    4444        return _compare(*cast(cfloat *)p1, *cast(cfloat *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return cfloat.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return cfloat.sizeof; 
    …… 
    6368 
    6469        return (cast(cfloat *)&r)[0 .. 1]; 
    6570    } 
     71 
     72    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     73    { 
     74        arg1 = typeid(double); 
     75        return 0; 
    6676} 
     77} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Acfloat.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (cfloat[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (cfloat[]).sizeof; 
    …… 
    9095    { 
    9196        return typeid(cfloat); 
    9297    } 
     98 
     99    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     100    { 
     101        return 0; 
    93102} 
     103} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_cdouble.d

    old new  
    4444        return _compare(*cast(cdouble *)p1, *cast(cdouble *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return cdouble.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return cdouble.sizeof; 
    …… 
    6368 
    6469        return (cast(cdouble *)&r)[0 .. 1]; 
    6570    } 
     71 
     72    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     73    { 
     74        return 0; 
    6675} 
     76} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_dchar.d

    old new  
    2222        return *cast(dchar *)p1 - *cast(dchar *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return dchar.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return dchar.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_C.d

    old new  
    6262        return c; 
    6363    } 
    6464 
     65    override size_t talign() 
     66    { 
     67        return Object.alignof; 
     68    } 
     69 
    6570    override size_t tsize() 
    6671    { 
    6772        return Object.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_real.d

    old new  
    4343        return _compare(*cast(real *)p1, *cast(real *)p2); 
    4444    } 
    4545 
     46    override size_t talign() 
     47    { 
     48        return real.alignof; 
     49    } 
     50 
    4651    override size_t tsize() 
    4752    { 
    4853        return real.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_ushort.d

    old new  
    2222        return *cast(ushort *)p1 - *cast(ushort *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return ushort.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return ushort.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Areal.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (real[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (real[]).sizeof; 
    …… 
    9095    { 
    9196        return typeid(real); 
    9297    } 
     98 
     99    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     100    { 
     101        return 0; 
    93102} 
     103} 
    94104 
    95105// ireal[] 
    96106 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Acreal.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (creal[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (creal[]).sizeof; 
    …… 
    9095    { 
    9196        return typeid(creal); 
    9297    } 
     98 
     99    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     100    { 
     101        return 0; 
    93102} 
     103} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Ag.d

    old new  
    4848        return 0; 
    4949    } 
    5050 
     51    override size_t talign() 
     52    { 
     53        return (byte[]).alignof; 
     54    } 
     55 
    5156    override size_t tsize() 
    5257    { 
    5358        return (byte[]).sizeof; 
    …… 
    117122 
    118123    override hash_t getHash(in void* p){ 
    119124        char[] s = *cast(char[]*)p; 
     125 
    120126        version (OldHash) 
    121127        { 
    122128            hash_t hash = 0; 
    …… 
    133139    { 
    134140        return typeid(char); 
    135141    } 
     142 
     143    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     144    { 
     145        return 0; 
    136146} 
     147} 

  • tango/core/rt/compiler/dmd/typeinfo/ti_int.d

    old new  
    2626        return 0; 
    2727    } 
    2828 
     29    override size_t talign() 
     30    { 
     31        return int.alignof; 
     32    } 
     33 
    2934    override size_t tsize() 
    3035    { 
    3136        return int.sizeof; 

  • tango/core/rt/compiler/dmd/typeinfo/ti_Ashort.d

    old new  
    4747        return 0; 
    4848    } 
    4949 
     50    override size_t talign() 
     51    { 
     52        return (short[]).alignof; 
     53    } 
     54 
    5055    override size_t tsize() 
    5156    { 
    5257        return (short[]).sizeof; 
    …… 
    6166    { 
    6267        return typeid(short); 
    6368    } 
     69 
     70    version (X86_64) override int argTypes(out TypeInfo arg1, out TypeInfo arg2) 
     71    { 
     72        arg1 = typeid(size_t); 
     73        arg2 = typeid(void*); 
     74        return 0; 
    6475} 
     76} 
    6577 
    6678 
    6779// ushort[] 

  • tango/core/rt/compiler/dmd/posix/deh.d

    old new  
    6464    void *fptr;                 // pointer to start of function 
    6565    uint espoffset;             // offset of ESP from EBP 
    6666    uint retoffset;             // offset from start of function to return code 
    67     uint nhandlers;             // dimension of handler_info[] 
     67    size_t nhandlers;             // dimension of handler_info[] 
    6868    DHandlerInfo handler_info[1]; 
    6969} 
    7070 
    7171struct DCatchBlock 
    7272{ 
    7373    ClassInfo type;             // catch type 
    74     uint bpoffset;              // EBP offset of catch var 
     74    size_t bpoffset;              // EBP offset of catch var 
    7575    void *code;                 // catch handler code 
    7676} 
    7777 
    7878// Create one of these for each try-catch 
    7979struct DCatchInfo 
    8080{ 
    81     uint ncatches;                      // number of catch blocks 
     81    size_t ncatches;                      // number of catch blocks 
    8282    DCatchBlock catch_block[1];         // data for each catch block 
    8383} 
    8484 
    …… 
    164164 *   caller's EBP 
    165165 */ 
    166166 
    167 uint __eh_find_caller(uint regbp, uint *pretaddr) 
     167size_t __eh_find_caller(size_t regbp, size_t *pretaddr) 
    168168{ 
    169     uint bp = *cast(uint *)regbp; 
     169    size_t bp = *cast(size_t *)regbp; 
    170170 
    171171    if (bp)         // if not end of call chain 
    172172    { 
    …… 
    176176            // stack should grow to smaller values 
    177177            terminate(); 
    178178 
    179         *pretaddr = *cast(uint *)(regbp + int.sizeof); 
     179        *pretaddr = *cast(size_t *)(regbp + size_t.sizeof); 
    180180    } 
    181181    return bp; 
    182182} 
    …… 
    195195* Throw a D object. 
    196196*/ 
    197197 
    198 extern(C) void _d_throwc(Object *h){ 
    199     uint regebp; 
     198extern(C) void _d_throwc(Object *h) 
     199{ 
     200    size_t regebp; 
    200201 
    201202    debug(deh) 
    202203    { 
    …… 
    204205        printf("\tvptr = %p\n", *cast(void **)h); 
    205206    } 
    206207 
     208    version (D_InlineAsm_X86) 
    207209    asm 
    208210    { 
    209211        mov regebp,EBP  ; 
    210212    } 
     213    else version (D_InlineAsm_X86_64) 
     214        asm 
     215        { 
     216            mov regebp,RBP  ; 
     217        } 
     218    else 
     219        static assert(0); 
    211220 
    212221//static uint abc; 
    213222//if (++abc == 2) *(char *)0=0; 
    …… 
    218227        DHandlerTable *handler_table; 
    219228        FuncTable *pfunc; 
    220229        DHandlerInfo *phi; 
    221         uint retaddr; 
    222         uint funcoffset; 
     230        size_t retaddr; 
     231        size_t funcoffset; 
    223232        uint spoff; 
    224233        uint retoffset; 
    225234        int index; 
    226         int dim; 
     235        size_t dim; 
    227236        int ndx; 
    228237        int prev_ndx; 
    229238 
    …… 
    244253            debug(deh) printf("no handler table\n"); 
    245254            continue; 
    246255        } 
    247         funcoffset = cast(uint)handler_table.fptr; 
     256        funcoffset = cast(size_t)handler_table.fptr; 
    248257        spoff = handler_table.espoffset; 
    249258        retoffset = handler_table.retoffset; 
    250259 
    …… 
    261270        debug(deh) 
    262271        { 
    263272            printf("handler_info[]:\n"); 
    264             for (int i = 0; i < dim; i++) 
     273            for (size_t i = 0; i < dim; i++) 
    265274            { 
    266275                phi = handler_table.handler_info.ptr + i; 
    267276                printf("\t[%d]: offset = x%04x, endoffset = x%04x, prev_index = %d, cioffset = x%04x, finally_code = %x\n", 
    …… 
    270279        } 
    271280 
    272281        index = -1; 
    273         for (int i = 0; i < dim; i++) 
     282        for (size_t i = 0; i < dim; i++) 
    274283        { 
    275284            phi = handler_table.handler_info.ptr + i; 
    276285 
    277286            debug(deh) printf("i = %d, phi.offset = %04x\n", i, funcoffset + phi.offset); 
    278             if (cast(uint)retaddr > funcoffset + phi.offset && 
    279                 cast(uint)retaddr <= funcoffset + phi.endoffset) 
     287            if (retaddr > funcoffset + phi.offset && 
     288                retaddr <= funcoffset + phi.endoffset) 
    280289                index = i; 
    281290        } 
    282291        debug(deh) printf("index = %d\n", index); 
    …… 
    287296        { 
    288297            phi = handler_table.handler_info.ptr + ndx; 
    289298            prev_ndx = phi.prev_index; 
     299 
    290300            if (phi.cioffset) 
    291301            { 
    292302                // this is a catch handler (no finally) 
    293303                DCatchInfo *pci; 
    294                 int ncatches; 
    295                 int i; 
     304                size_t ncatches; 
     305                size_t i; 
    296306 
    297307                pci = cast(DCatchInfo *)(cast(char *)handler_table + phi.cioffset); 
    298308                ncatches = pci.ncatches; 
     309 
    299310                for (i = 0; i < ncatches; i++) 
    300311                { 
    301312                    DCatchBlock *pcb; 
    …… 
    311322 
    312323                        // Jump to catch block. Does not return. 
    313324                        { 
    314                             uint catch_esp; 
     325                            size_t catch_esp; 
    315326                            fp_t catch_addr; 
    316327 
    317328                            catch_addr = cast(fp_t)(pcb.code); 
    318329                            catch_esp = regebp - handler_table.espoffset - fp_t.sizeof; 
     330 
     331                            version (D_InlineAsm_X86) 
    319332                            asm 
    320333                            { 
    321334                                mov     EAX,catch_esp   ; 
    …… 
    325338                                mov     ESP,EAX         ; // reset stack 
    326339                                ret                     ; // jump to catch block 
    327340                            } 
     341                            else version (D_InlineAsm_X86_64) 
     342                                asm 
     343                                { 
     344                                    mov     RAX,catch_esp   ; 
     345                                    mov     RCX,catch_esp   ; 
     346                                    mov     RCX,catch_addr  ; 
     347                                    mov     [RAX],RCX       ; 
     348                                    mov     RBP,regebp      ; 
     349                                    mov     RSP,RAX         ; // reset stack 
     350                                    ret                     ; // jump to catch block 
    328351                        } 
     352                            else 
     353                                static assert(0); 
     354 
    329355                    } 
    330356                } 
    331357            } 
     358            } 
    332359            else if (phi.finally_code) 
    333360            {   // Call finally block 
    334361                // Note that it is unnecessary to adjust the ESP, as the finally block 
    …… 
    338365 
    339366                version (OSX) 
    340367                { 
    341                     asm { 
     368                    version (D_InlineAsm_X86) 
     369                        asm 
     370                        { 
    342371                        sub ESP,4       ; 
    343372                        push    EBX     ; 
    344373                        mov EBX,blockaddr   ; 
    …… 
    349378                        pop EBX     ; 
    350379                        add ESP,4       ; 
    351380                    } 
    352                 } else { 
    353                     asm { 
     381                    else version (D_InlineAsm_X86_64) 
     382                        asm 
     383                        { 
     384                            sub     RSP,8           ; 
     385                            push    RBX             ; 
     386                            mov     RBX,blockaddr   ; 
     387                            push    RBP             ; 
     388                            mov     RBP,regebp      ; 
     389                            call    RBX             ; 
     390                            pop     RBP             ; 
     391                            pop     RBX             ; 
     392                            add     RSP,8           ; 
     393                        } 
     394                    else 
     395                        static assert(0); 
     396                } 
     397                else 
     398                { 
     399                    version (D_InlineAsm_X86) 
     400                        asm 
     401                        { 
    354402                        push        EBX             ; 
    355403                        mov         EBX,blockaddr   ; 
    356404                        push        EBP             ; 
    …… 
    359407                        pop         EBP             ; 
    360408                        pop         EBX             ; 
    361409                    } 
     410                    else version (D_InlineAsm_X86_64) 
     411                        asm 
     412                        { 
     413                            sub     RSP,8           ; 
     414                            push    RBX             ; 
     415                            mov     RBX,blockaddr   ; 
     416                            push    RBP             ; 
     417                            mov     RBP,regebp      ; 
     418                            call    RBX             ; 
     419                            pop     RBP             ; 
     420                            pop     RBX             ; 
     421                            add     RSP,8           ; 
    362422                } 
     423                    else 
     424                        static assert(0); 
    363425            } 
    364426        } 
    365427    } 
    366428} 
     429} 

  • tango/core/rt/compiler/dmd/posix/llmath.d

    old new  
    1919 *      [ECX,EBX] = [EDX,EAX] % [ECX,EBX] 
    2020 */ 
    2121 
     22 
    2223void __ULDIV__() 
    2324{ 
     25  version (D_InlineAsm_X86) 
    2426    asm 
    2527    { 
    2628        naked                   ; 
    …… 
    178180        xor     EDX,EDX         ; 
    179181        ret                     ; 
    180182    } 
     183  else version (D_InlineAsm_X86_64) 
     184        assert(0); 
     185  else 
     186        static assert(0); 
    181187} 
    182188 
    183189 
    …… 
    193199 
    194200void __LDIV__() 
    195201{ 
     202  version (D_InlineAsm_X86) 
    196203    asm 
    197204    { 
    198205        naked                   ; 
    …… 
    241248 
    242249L12:    jmp     __ULDIV__       ; 
    243250    } 
     251  else version (D_InlineAsm_X86_64) 
     252        assert(0); 
     253  else 
     254        static assert(0); 
    244255} 
    245256 
    246  
    247257/*************************************** 
    248258 * Compare [EDX,EAX] with [ECX,EBX] 
    249259 * Signed 
    …… 
    252262 
    253263void __LCMP__() 
    254264{ 
     265  version (D_InlineAsm_X86) 
    255266    asm 
    256267    { 
    257268        naked                   ; 
    …… 
    270281C2:     pop     EDX             ; 
    271282C1:     ret                     ; 
    272283    } 
     284  else version (D_InlineAsm_X86_64) 
     285        assert(0); 
     286  else 
     287        static assert(0); 
    273288} 
    274289 
    275  
    276  
    277  
    278290// Convert ulong to real 
    279291 
    280292private real adjust = cast(real)0x800_0000_0000_0000 * 0x10; 
    281293 
    282294real __U64_LDBL() 
    283295{ 
    284     version (OSX) { 
     296    version (OSX) 
     297    { 
     298      version (D_InlineAsm_X86) 
    285299        asm 
    286300        {   naked               ; 
    287301            push    EDX         ; 
    …… 
    300314            add     ESP, 8          ; 
    301315            ret                 ; 
    302316        } 
    303     } else { 
     317      else version (D_InlineAsm_X86_64) 
     318            static assert(0); 
     319      else 
     320            static assert(0); 
     321    } 
     322    else 
     323    { 
     324      version (D_InlineAsm_X86) 
    304325        asm 
    305326        {   naked                                   ; 
    306327            push    EDX                             ; 
    …… 
    315336            add     ESP, 8                          ; 
    316337            ret                                     ; 
    317338        } 
     339      else version (D_InlineAsm_X86_64) 
     340        asm 
     341        {   naked                               ; 
     342            push        RAX                     ; 
     343            and         dword ptr 4[RSP], 0x7FFFFFFF    ; 
     344            fild        qword ptr [RSP]         ; 
     345            test        RAX,RAX                 ; 
     346            jns         L1                      ; 
     347            fld         real ptr adjust         ; 
     348            faddp       ST(1), ST               ; 
     349        L1:                                     ; 
     350            add         RSP, 8                  ; 
     351            ret                                 ; 
    318352    } 
     353      else 
     354            static assert(0); 
    319355} 
     356} 
    320357 
    321358// Same as __U64_LDBL, but return result as double in [EDX,EAX] 
    322359ulong __ULLNGDBL() 
    323360{ 
     361  version (D_InlineAsm_X86) 
    324362    asm 
    325363    {   naked                                   ; 
    326364        call __U64_LDBL                         ; 
    …… 
    330368        pop  EDX                                ; 
    331369        ret                                     ; 
    332370    } 
     371  else version (D_InlineAsm_X86_64) 
     372    asm 
     373    {   naked                                   ; 
     374        call __U64_LDBL                         ; 
     375        sub  RSP,8                              ; 
     376        fstp double ptr [RSP]                   ; 
     377        pop  RAX                                ; 
     378        ret                                     ; 
    333379} 
     380  else 
     381        static assert(0); 
     382} 
    334383 
     384 
    335385// Convert double to ulong 
    336386 
    337387private short roundTo0 = 0xFBF; 
    …… 
    339389ulong __DBLULLNG() 
    340390{ 
    341391    // BUG: should handle NAN's and overflows 
    342     version (OSX) { 
    343         asm { 
    344             naked               ; 
     392    version (OSX) 
     393    { 
     394      version (D_InlineAsm_X86) 
     395        asm 
     396        {   naked                               ; 
    345397            push    0xFBF           ; // roundTo0 
    346398            push    0x0000403e      ; 
    347399            push    0x80000000      ; 
    …… 
    374426            add     ESP,24          ; 
    375427            ret                 ; 
    376428        } 
    377     } else { 
     429      else version (D_InlineAsm_X86_64) 
     430            static assert(0); 
     431      else 
     432            static assert(0); 
     433    } 
     434    else 
     435    { 
     436      version (D_InlineAsm_X86) 
    378437        asm 
    379438        {   naked                                   ; 
    380439            push    EDX                             ; 
    …… 
    405464            add     ESP,8                           ; 
    406465            ret                                     ; 
    407466        } 
     467      else version (D_InlineAsm_X86_64) 
     468        asm 
     469        {   naked                               ; 
     470            push        RAX                     ; 
     471            fld         double ptr [RSP]        ; 
     472            sub         RSP,8                   ; 
     473            fld         real ptr adjust         ; 
     474            fcomp                               ; 
     475            fstsw       AX                      ; 
     476            fstcw       8[RSP]                  ; 
     477            fldcw       roundTo0                ; 
     478            sahf                                ; 
     479            jae         L1                      ; 
     480            fld         real ptr adjust         ; 
     481            fsubp       ST(1), ST               ; 
     482            fistp       qword ptr [RSP]         ; 
     483            pop         RAX                     ; 
     484            fldcw       [RSP]                   ; 
     485            add         RSP,8                   ; 
     486            mov         EDX,0x8000_0000         ; 
     487            shl         RDX,32                  ; 
     488            add         RAX,RDX                 ; 
     489            ret                                 ; 
     490        L1:                                     ; 
     491            fistp       qword ptr [RSP]         ; 
     492            pop         RAX                     ; 
     493            fldcw       [RSP]                   ; 
     494            add         RSP,8                   ; 
     495            ret                                 ; 
    408496    } 
     497      else 
     498            static assert(0); 
    409499} 
     500} 
    410501 
    411502// Convert double in ST0 to uint 
    412503 
    413504uint __DBLULNG() 
    414505{ 
    415506    // BUG: should handle NAN's and overflows 
    416     version (OSX) { 
    417         asm { 
    418             naked                   ; 
     507    version (OSX) 
     508    { 
     509      version (D_InlineAsm_X86) 
     510        asm 
     511        {   naked                               ; 
    419512            push    0xFBF           ; // roundTo0 
    420513            sub     ESP,12          ; 
    421514            fstcw   8[ESP]          ; 
    …… 
    426519            add     ESP,12          ; 
    427520            ret                     ; 
    428521        } 
    429     } else { 
    430         asm { 
    431             naked                                   ; 
     522      else version (D_InlineAsm_X86_64) 
     523            assert(0); 
     524      else 
     525            static assert(0); 
     526    } 
     527    else 
     528    { 
     529      version (D_InlineAsm_X86) 
     530        asm 
     531        {   naked                               ; 
    432532            sub     ESP,16                          ; 
    433533            fstcw   8[ESP]                          ; 
    434534            fldcw   roundTo0                        ; 
    …… 
    438538            add     ESP,12                          ; 
    439539            ret                                     ; 
    440540        } 
     541      else version (D_InlineAsm_X86_64) 
     542        asm 
     543        {   naked                               ; 
     544            sub         RSP,16                  ; 
     545            fstcw       8[RSP]                  ; 
     546            fldcw       roundTo0                ; 
     547            fistp       qword ptr [RSP]         ; 
     548            fldcw       8[RSP]                  ; 
     549            pop         RAX                     ; 
     550            add         RSP,8                   ; 
     551            ret                                 ; 
    441552    } 
     553      else 
     554            static assert(0); 
    442555} 
     556} 
    443557 
    444  
    445558// Convert real in ST0 to ulong 
    446559 
    447560ulong __LDBLULLNG() 
    448561{ 
    449562    version (OSX) 
    450563    { 
     564      version (D_InlineAsm_X86) 
    451565    asm 
    452566    {   naked               ; 
    453567        push    0xFBF           ; // roundTo0 
    …… 
    479593        add     ESP,24          ; 
    480594        ret                 ; 
    481595    } 
     596      else version (D_InlineAsm_X86_64) 
     597            static assert(0); 
     598      else 
     599            static assert(0); 
    482600    } 
    483601    else 
    484602    { 
     603      version (D_InlineAsm_X86) 
    485604    asm 
    486605    {   naked               ; 
    487606        sub     ESP,16          ; 
    …… 
    509628        add     ESP,8           ; 
    510629        ret                 ; 
    511630    } 
     631      else version (D_InlineAsm_X86_64) 
     632        asm 
     633        {   naked                               ; 
     634            sub         RSP,16                  ; 
     635            fld         real ptr adjust         ; 
     636            fcomp                               ; 
     637            fstsw       AX                      ; 
     638            fstcw       8[RSP]                  ; 
     639            fldcw       roundTo0                ; 
     640            sahf                                ; 
     641            jae         L1                      ; 
     642            fld         real ptr adjust         ; 
     643            fsubp       ST(1), ST               ; 
     644            fistp       qword ptr [RSP]         ; 
     645            pop         RAX                     ; 
     646            fldcw       [RSP]                   ; 
     647            add         RSP,8                   ; 
     648            mov         RCX,0x8000_0000         ; 
     649            shl         RCX,32                  ; 
     650            add         RAX,RCX                 ; 
     651            ret                                 ; 
     652        L1:                                     ; 
     653            fistp       qword ptr [RSP]         ; 
     654            pop         RAX                     ; 
     655            fldcw       [RSP]                   ; 
     656            add         RSP,8                   ; 
     657            ret                                 ; 
    512658    } 
     659      else 
     660            static assert(0); 
    513661} 
    514  
     662} 

  • tango/core/rt/compiler/gdc/object_.d

    old new  
    413413    /// Compares two instances for &lt;, ==, or &gt;. 
    414414    int compare(in void* p1, in void* p2) { return 0; } // throw new Exception("non comparable",__FILE__,__LINE__); 
    415415 
     416     /// Return alignment of type 
     417    size_t   talign() { return tsize(); } 
     418 
    416419    /// Returns size of the type. 
    417420    size_t tsize() { return 0; } 
    418421 

  • tango/core/rt/compiler/gdc/typeinfo/ti_void.d

    old new  
    2222        return *cast(byte *)p1 - *cast(byte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return void.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return void.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_wchar.d

    old new  
    2121        return *cast(wchar *)p1 - *cast(wchar *)p2; 
    2222    } 
    2323 
     24    override size_t talign() 
     25    { 
     26        return wchar.alignof; 
     27    } 
     28 
    2429    override size_t tsize() 
    2530    { 
    2631        return wchar.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_ptr.d

    old new  
    2525        return 0; 
    2626    } 
    2727 
     28    override size_t talign() 
     29    { 
     30        return (void*).alignof; 
     31    } 
     32 
    2833    override size_t tsize() 
    2934    { 
    3035        return (void*).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Afloat.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (float[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (float[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_double.d

    old new  
    4343        return _compare(*cast(double *)p1, *cast(double *)p2); 
    4444    } 
    4545 
     46    override size_t talign() 
     47    { 
     48        return double.alignof; 
     49    } 
     50 
    4651    override size_t tsize() 
    4752    { 
    4853        return double.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_delegate.d

    old new  
    1818        return *cast(dg *)p1 == *cast(dg *)p2; 
    1919    } 
    2020 
     21    override size_t talign() 
     22    { 
     23        return dg.alignof; 
     24    } 
     25 
    2126    override size_t tsize() 
    2227    { 
    2328        return dg.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Adouble.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (double[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (double[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_char.d

    old new  
    2020        return *cast(char *)p1 - *cast(char *)p2; 
    2121    } 
    2222 
     23    override size_t talign() 
     24    { 
     25        return char.alignof; 
     26    } 
     27 
    2328    override size_t tsize() 
    2429    { 
    2530        return char.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Acdouble.d

    old new  
    7575        return 0; 
    7676    } 
    7777 
     78    override size_t talign() 
     79    { 
     80        return (cdouble[]).alignof; 
     81    } 
     82 
    7883    override size_t tsize() 
    7984    { 
    8085        return (cdouble[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_uint.d

    old new  
    2626        return 0; 
    2727    } 
    2828 
     29    override size_t talign() 
     30    { 
     31        return uint.alignof; 
     32    } 
     33 
    2934    override size_t tsize() 
    3035    { 
    3136        return uint.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_AC.d

    old new  
    8282        return 0; 
    8383    } 
    8484 
     85    override size_t talign() 
     86    { 
     87        return (Object[]).alignof; 
     88    } 
     89 
    8590    override size_t tsize() 
    8691    { 
    8792        return (Object[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_ulong.d

    old new  
    3131        return 0; 
    3232    } 
    3333 
     34    override size_t talign() 
     35    { 
     36        return ulong.alignof; 
     37    } 
     38 
    3439    override size_t tsize() 
    3540    { 
    3641        return ulong.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_creal.d

    old new  
    4444        return _compare(*cast(creal *)p1, *cast(creal *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return creal.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return creal.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_ubyte.d

    old new  
    2222        return *cast(ubyte *)p1 - *cast(ubyte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return ubyte.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return ubyte.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Aint.d

    old new  
    4747        return 0; 
    4848    } 
    4949 
     50    override size_t talign() 
     51    { 
     52        return (int[]).alignof; 
     53    } 
     54 
    5055    override size_t tsize() 
    5156    { 
    5257        return (int[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_long.d

    old new  
    3131        return 0; 
    3232    } 
    3333 
     34    override size_t talign() 
     35    { 
     36        return long.alignof; 
     37    } 
     38 
    3439    override size_t tsize() 
    3540    { 
    3641        return long.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_short.d

    old new  
    2222        return *cast(short *)p1 - *cast(short *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return short.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return short.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Along.d

    old new  
    4848        return 0; 
    4949    } 
    5050 
     51    override size_t talign() 
     52    { 
     53        return (long[]).alignof; 
     54    } 
     55 
    5156    override size_t tsize() 
    5257    { 
    5358        return (long[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_byte.d

    old new  
    2222        return *cast(byte *)p1 - *cast(byte *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return byte.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return byte.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_float.d

    old new  
    4242        return _compare(*cast(float *)p1, *cast(float *)p2); 
    4343    } 
    4444 
     45    override size_t talign() 
     46    { 
     47        return float.alignof; 
     48    } 
     49 
    4550    override size_t tsize() 
    4651    { 
    4752        return float.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_cfloat.d

    old new  
    4444        return _compare(*cast(cfloat *)p1, *cast(cfloat *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return cfloat.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return cfloat.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Acfloat.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (cfloat[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (cfloat[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_cdouble.d

    old new  
    4444        return _compare(*cast(cdouble *)p1, *cast(cdouble *)p2); 
    4545    } 
    4646 
     47    override size_t talign() 
     48    { 
     49        return cdouble.alignof; 
     50    } 
     51 
    4752    override size_t tsize() 
    4853    { 
    4954        return cdouble.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_dchar.d

    old new  
    2222        return *cast(dchar *)p1 - *cast(dchar *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return dchar.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return dchar.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_C.d

    old new  
    6262        return c; 
    6363    } 
    6464 
     65    override size_t talign() 
     66    { 
     67        return Object.alignof; 
     68    } 
     69 
    6570    override size_t tsize() 
    6671    { 
    6772        return Object.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_real.d

    old new  
    4343        return _compare(*cast(real *)p1, *cast(real *)p2); 
    4444    } 
    4545 
     46    override size_t talign() 
     47    { 
     48        return real.alignof; 
     49    } 
     50 
    4651    override size_t tsize() 
    4752    { 
    4853        return real.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_ushort.d

    old new  
    2222        return *cast(ushort *)p1 - *cast(ushort *)p2; 
    2323    } 
    2424 
     25    override size_t talign() 
     26    { 
     27        return ushort.alignof; 
     28    } 
     29 
    2530    override size_t tsize() 
    2631    { 
    2732        return ushort.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Areal.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (real[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (real[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Acreal.d

    old new  
    7676        return 0; 
    7777    } 
    7878 
     79    override size_t talign() 
     80    { 
     81        return (creal[]).alignof; 
     82    } 
     83 
    7984    override size_t tsize() 
    8085    { 
    8186        return (creal[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Ag.d

    old new  
    4848        return 0; 
    4949    } 
    5050 
     51    override size_t talign() 
     52    { 
     53        return (byte[]).alignof; 
     54    } 
     55 
    5156    override size_t tsize() 
    5257    { 
    5358        return (byte[]).sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_int.d

    old new  
    2626        return 0; 
    2727    } 
    2828 
     29    override size_t talign() 
     30    { 
     31        return int.alignof; 
     32    } 
     33 
    2934    override size_t tsize() 
    3035    { 
    3136        return int.sizeof; 

  • tango/core/rt/compiler/gdc/typeinfo/ti_Ashort.d

    old new  
    4747        return 0; 
    4848    } 
    4949 
     50    override size_t talign() 
     51    { 
     52        return (short[]).alignof; 
     53    } 
     54 
    5055    override size_t tsize() 
    5156    { 
    5257        return (short[]).sizeof; 

  • tango/core/Variant.d

    old new  
    88module tango.core.Variant; 
    99 
    1010private import tango.core.Memory : GC; 
    11 private import tango.core.Vararg : va_list; 
     11private import tango.core.Vararg; 
    1212private import tango.core.Traits; 
    1313private import tango.core.Tuple; 
    1414 
    …… 
    3737            version=EnableVararg; 
    3838        } 
    3939    } 
     40    version( X86_64 ) 
     41    { 
     42        version( Windows ) 
     43        { 
     44            version=EnableVararg; 
    4045} 
     46        else version( Posix ) 
     47        { 
     48            version=EnableVararg; 
     49        } 
     50    } 
     51} 
    4152else version( LDC ) 
    4253{ 
    4354    version( X86 ) 

  • tango/core/Thread.d

    old new  
    348348            { 
    349349                __builtin_unwind_init(); 
    350350            } 
     351            else version ( D_InlineAsm_X86_64 ) 
     352            { 
     353                asm 
     354                { 
     355                    // Not sure what goes here, pushad is invalid in 64 bit code 
     356                    push RAX ; 
     357                    push RBX ; 
     358                    push RCX ; 
     359                    push RDX ; 
     360                    push RSI ; 
     361                    push RDI ; 
     362                    push RBP ; 
     363                    push R8  ; 
     364                    push R9  ; 
     365                    push R10 ; 
     366                    push R11 ; 
     367                    push R12 ; 
     368                    push R13 ; 
     369                    push R14 ; 
     370                    push R15 ; 
     371                    push EAX ;   // 16 byte align the stack 
     372                } 
     373            } 
    351374            else 
    352375            { 
    353376                static assert( false, "Architecture not supported." ); 
    …… 
    411434            { 
    412435                // registers will be popped automatically 
    413436            } 
     437            else version ( D_InlineAsm_X86_64 ) 
     438            { 
     439                asm 
     440                { 
     441                    // Not sure what goes here, popad is invalid in 64 bit code 
     442                    pop EAX ;   // 16 byte align the stack 
     443                    pop R15 ; 
     444                    pop R14 ; 
     445                    pop R13 ; 
     446                    pop R12 ; 
     447                    pop R11 ; 
     448                    pop R10 ; 
     449                    pop R9  ; 
     450                    pop R8  ; 
     451                    pop RBP ; 
     452                    pop RDI ; 
     453                    pop RSI ; 
     454                    pop RDX ; 
     455                    pop RCX ; 
     456                    pop RBX ; 
     457                    pop RAX ; 
     458                } 
     459            } 
    414460            else 
    415461            { 
    416462                static assert( false, "Architecture not supported." ); 
    …… 
    26702716        } 
    26712717        else version( AsmX86_64_Posix ) 
    26722718        { 
    2673             asm 
     2719            version( DigitalMars ) asm 
    26742720            { 
    26752721                naked; 
    26762722 
    26772723                // save current stack state 
     2724                push RBP; 
     2725                mov RBP, RSP; 
     2726                push RBX; 
     2727                push R12; 
     2728                push R13; 
     2729                push R14; 
     2730                push R15; 
     2731                sub RSP, 4; 
     2732                stmxcsr [RSP]; 
     2733                sub RSP, 4; 
     2734                //version(SynchroFloatExcept){ 
     2735                    fstcw [RSP]; 
     2736                    fwait; 
     2737                //} else { 
     2738                //    fnstcw [RSP]; 
     2739                //    fnclex; 
     2740                //} 
     2741 
     2742                // store oldp again with more accurate address 
     2743                mov [RDI], RSP; 
     2744                // load newp to begin context switch 
     2745                mov RSP, RSI; 
     2746 
     2747                // load saved state from new stack 
     2748                fldcw [RSP]; 
     2749                add RSP, 4; 
     2750                ldmxcsr [RSP]; 
     2751                add RSP, 4; 
     2752                pop R15; 
     2753                pop R14; 
     2754                pop R13; 
     2755                pop R12; 
     2756 
     2757                pop RBX; 
     2758                pop RBP; 
     2759 
     2760                // 'return' to complete switch 
     2761                ret; 
     2762 
     2763            } 
     2764            else asm 
     2765            { 
     2766                naked; 
     2767 
     2768                // save current stack state 
    26782769                pushq RBP; 
    26792770                mov RBP, RSP; 
    26802771                pushq RBX; 

  • tango/core/vendor/std/intrinsic.di

    old new  
    2525 *  The bit number of the first bit set. 
    2626 *  The return value is undefined if v is zero. 
    2727 */ 
    28 int bsf( uint v ); 
     28int bsf( size_t v ); 
    2929 
    3030 
    3131/** 

  • tango/core/Vararg.d

    old new  
    2121} 
    2222else 
    2323{ 
    24     /** 
    25      * The base vararg list type. 
    26      */ 
     24    version (X86) 
     25    { 
    2726    alias void* va_list; 
    2827 
    29  
    30     /** 
    31      * This function initializes the supplied argument pointer for subsequent 
    32      * use by va_arg and va_end. 
    33      * 
    34      * Params: 
    35      *  ap      = The argument pointer to initialize. 
    36      *  paramn  = The identifier of the rightmost parameter in the function 
    37      *            parameter list. 
    38      */ 
    39     void va_start(T) ( out va_list ap, ref T parmn ) 
     28        template va_arg(T) 
    4029    { 
    41         ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) ); 
    42     } 
    43  
    44     /** 
    45      * This function returns the next argument in the sequence referenced by 
    46      * the supplied argument pointer.  The argument pointer will be adjusted 
    47      * to point to the next arggument in the sequence. 
    48      * 
    49      * Params: 
    50      *  ap  = The argument pointer. 
    51      * 
    52      * Returns: 
    53      *  The next argument in the sequence.  The result is undefined if ap 
    54      *  does not point to a valid argument. 
    55      */ 
    56     T va_arg(T) ( ref va_list ap ) 
     30            T va_arg(ref va_list _argptr) 
    5731    { 
    58         T arg = *cast(T*) ap; 
    59         ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) ); 
     32                T arg = *cast(T*)_argptr; 
     33                _argptr = _argptr + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1)); 
    6034        return arg; 
    6135    } 
    62  
    63     /** 
    64      * This function cleans up any resources allocated by va_start.  It is 
    65      * currently a no-op and exists mostly for syntax compatibility with 
    66      * the variadric argument functions for C. 
    67      * 
    68      * Params: 
    69      *  ap  = The argument pointer. 
    70      */ 
    71     void va_end( va_list ap ) 
    72     { 
    73  
    7436    } 
    75  
    76  
    77     /** 
    78      * This function copied the argument pointer src to dst. 
    79      * 
    80      * Params: 
    81      *  src = The source pointer. 
    82      *  dst = The destination pointer. 
    83      */ 
    84     void va_copy( out va_list dst, va_list src ) 
     37    } 
     38    else 
    8539    { 
    86         dst = src; 
     40        public import tango.stdc.stdarg; 
    8741    } 
    8842} 

  • tango/core/sync/Atomic.d

    old new  
    245245        return oldval; 
    246246    } 
    247247} else version(D_InlineAsm_X86) { 
    248     T atomicSwap( T )( inout T val, T newval ) 
     248    T atomicSwap( T )( ref T val, T newval ) 
    249249    in { 
    250250        // NOTE: 32 bit x86 systems support 8 byte CAS, which only requires 
    251251        //       4 byte alignment, so use size_t as the align type here. 
    …… 
    289289        } 
    290290    } 
    291291} else version (D_InlineAsm_X86_64){ 
    292     T atomicSwap( T )( inout T val, T newval ) 
     292    T atomicSwap( T )( ref T val, T newval ) 
    293293    in { 
    294294        assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) ); 
    295295    } body { 
    …… 
    332332        } 
    333333    } 
    334334} else { 
    335     T atomicSwap( T )( inout T val, T newval ) 
     335    T atomicSwap( T )( ref T val, T newval ) 
    336336    in { 
    337337        assert( atomicValueIsProperlyAligned!(T)( cast(size_t) &val ) ); 
    338338    } body { 

  • tango/stdc/stdarg.d

    old new  
    99module tango.stdc.stdarg; 
    1010 
    1111 
     12debug(PRINTF) import tango.stdc.stdio: printf; 
     13 
     14 
    1215version( GNU ) 
    1316{ 
    1417    public import std.c.stdarg; 
    …… 
    1922} 
    2023else 
    2124{ 
     25version (X86) 
     26{ 
     27    /********************* 
     28     * The argument pointer type. 
     29     */ 
    2230    alias void* va_list; 
    2331 
    24     template va_start( T ) 
     32    /********** 
     33     * Initialize ap. 
     34     * For 32 bit code, parmn should be the last named parameter. 
     35     * For 64 bit code, parmn should be __va_argsave. 
     36     */ 
     37    void va_start(T)(out va_list ap, ref T parmn) 
    2538    { 
    26         void va_start( out va_list ap, ref T parmn ) 
    27         { 
    2839            ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) ); 
    2940        } 
    30     } 
    3141 
    32     template va_arg( T ) 
     42    /************ 
     43     * Retrieve and return the next value that is type T. 
     44     * Should use the other va_arg instead, as this won't work for 64 bit code. 
     45     */ 
     46    T va_arg(T)(ref va_list ap) 
    3347    { 
    34         T va_arg( ref va_list ap ) 
    35         { 
    3648            T arg = *cast(T*) ap; 
    3749            ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) ); 
    3850            return arg; 
    3951        } 
     52 
     53    /************ 
     54     * Retrieve and return the next value that is type T. 
     55     * This is the preferred version. 
     56     */ 
     57    void va_arg(T)(ref va_list ap, ref T parmn) 
     58    { 
     59        parmn = *cast(T*)ap; 
     60        ap = cast(va_list)(cast(void*)ap + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1))); 
    4061    } 
    4162 
     63    /************* 
     64     * Retrieve and store through parmn the next value that is of TypeInfo ti. 
     65     * Used when the static type is not known. 
     66     */ 
     67    void va_arg()(ref va_list ap, TypeInfo ti, void* parmn) 
     68    { 
     69        // Wait until everyone updates to get TypeInfo.talign() 
     70        //auto talign = ti.talign(); 
     71        //auto p = cast(void*)(cast(size_t)ap + talign - 1) & ~(talign - 1); 
     72        auto p = ap; 
     73        auto tsize = ti.tsize(); 
     74        ap = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1))); 
     75        parmn[0..tsize] = p[0..tsize]; 
     76    } 
     77 
     78    /*********************** 
     79     * End use of ap. 
     80     */ 
    4281    void va_end( va_list ap ) 
    4382    { 
     83    } 
    4484 
     85    void va_copy(out va_list dest, va_list src) 
     86    { 
     87        dest = src; 
    4588    } 
     89} 
     90else version (X86_64) 
     91{ 
     92    // Layout of this struct must match __gnuc_va_list for C ABI compatibility 
     93    struct __va_list 
     94    { 
     95        uint offset_regs = 6 * 8;            // no regs 
     96        uint offset_fpregs = 6 * 8 + 8 * 16; // no fp regs 
     97        void* stack_args; 
     98        void* reg_args; 
     99    } 
    46100 
     101    struct __va_argsave_t 
     102    { 
     103        size_t[6] regs;   // RDI,RSI,RDX,RCX,R8,R9 
     104        real[8] fpregs;   // XMM0..XMM7 
     105        __va_list va; 
     106    } 
     107 
     108    /* 
     109     * Making it an array of 1 causes va_list to be passed as a pointer in 
     110     * function argument lists 
     111     */ 
     112    alias void* va_list; 
     113 
     114    void va_start(T)(out va_list ap, ref T parmn) 
     115    { 
     116        ap = &parmn.va; 
     117    } 
     118 
     119    T va_arg(T)(va_list ap) 
     120    {   T a; 
     121        va_arg(ap, a); 
     122        return a; 
     123    } 
     124 
     125    void va_arg(T)(va_list apx, ref T parmn) 
     126    { 
     127        debug(PRINTF) printf("va_arg(T) called\n"); 
     128        __va_list* ap = cast(__va_list*)apx; 
     129        static if (is(T U == __argTypes)) 
     130        { 
     131            static if (U.length == 0 || T.sizeof > 16 || U[0].sizeof > 8) 
     132            {   // Always passed in memory 
     133                // The arg may have more strict alignment than the stack 
     134                auto p = (cast(size_t)ap.stack_args + T.alignof - 1) & ~(T.alignof - 1); 
     135                ap.stack_args = cast(void*)(p + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1))); 
     136                parmn = *cast(T*)p; 
     137            } 
     138            else static if (U.length == 1) 
     139            {   // Arg is passed in one register 
     140                alias U[0] T1; 
     141                static if (is(T1 == double) || is(T1 == float)) 
     142                {   // Passed in XMM register 
     143                    if (ap.offset_fpregs < (6 * 8 + 16 * 8)) 
     144                    { 
     145                        parmn = *cast(T*)(ap.reg_args + ap.offset_fpregs); 
     146                        ap.offset_fpregs += 16; 
     147                    } 
     148                    else 
     149                    { 
     150                        parmn = *cast(T*)ap.stack_args; 
     151                        ap.stack_args += (T1.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1); 
     152                    } 
     153                } 
     154                else 
     155                {   // Passed in regular register 
     156                    if (ap.offset_regs < 6 * 8 && T.sizeof <= 8) 
     157                    { 
     158                        parmn = *cast(T*)(ap.reg_args + ap.offset_regs); 
     159                        ap.offset_regs += 8; 
     160                    } 
     161                    else 
     162                    { 
     163                        auto p = (cast(size_t)ap.stack_args + T.alignof - 1) & ~(T.alignof - 1); 
     164                        ap.stack_args = cast(void*)(p + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1))); 
     165                        parmn = *cast(T*)p; 
     166                    } 
     167                } 
     168            } 
     169            else static if (U.length == 2) 
     170            {   // Arg is passed in two registers 
     171                alias U[0] T1; 
     172                alias U[1] T2; 
     173 
     174                static if (is(T1 == double) || is(T1 == float)) 
     175                { 
     176                    if (ap.offset_fpregs < (6 * 8 + 16 * 8)) 
     177                    { 
     178                        *cast(T1*)&parmn = *cast(T1*)(ap.reg_args + ap.offset_fpregs); 
     179                        ap.offset_fpregs += 16; 
     180                    } 
     181                    else 
     182                    { 
     183                        *cast(T1*)&parmn = *cast(T1*)ap.stack_args; 
     184                        ap.stack_args += (T1.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1); 
     185                    } 
     186                } 
     187                else 
     188                { 
     189                    if (ap.offset_regs < 6 * 8 && T1.sizeof <= 8) 
     190                    { 
     191                        *cast(T1*)&parmn = *cast(T1*)(ap.reg_args + ap.offset_regs); 
     192                        ap.offset_regs += 8; 
     193                    } 
     194                    else 
     195                    { 
     196                        *cast(T1*)&parmn = *cast(T1*)ap.stack_args; 
     197                        ap.stack_args += 8; 
     198                    } 
     199                } 
     200 
     201                auto p = cast(void*)&parmn + 8; 
     202                static if (is(T2 == double) || is(T2 == float)) 
     203                { 
     204                    if (ap.offset_fpregs < (6 * 8 + 16 * 8)) 
     205                    { 
     206                        *cast(T2*)p = *cast(T2*)(ap.reg_args + ap.offset_fpregs); 
     207                        ap.offset_fpregs += 16; 
     208                    } 
     209                    else 
     210                    { 
     211                        *cast(T2*)p = *cast(T2*)ap.stack_args; 
     212                        ap.stack_args += (T2.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1); 
     213                    } 
     214                } 
     215                else 
     216                { 
     217                    void* a = void; 
     218                    if (ap.offset_regs < 6 * 8 && T2.sizeof <= 8) 
     219                    { 
     220                        a = ap.reg_args + ap.offset_regs; 
     221                        ap.offset_regs += 8; 
     222                    } 
     223                    else 
     224                    { 
     225                        a = ap.stack_args; 
     226                        ap.stack_args += 8; 
     227                    } 
     228                    // Be careful not to go past the size of the actual argument 
     229                    const sz2 = T.sizeof - 8; 
     230                    p[0..sz2] = a[0..sz2]; 
     231                } 
     232            } 
     233            else 
     234            { 
     235                static assert(0); 
     236            } 
     237        } 
     238        else 
     239        { 
     240            static assert(0, "not a valid argument type for va_arg"); 
     241        } 
     242    } 
     243 
     244    void va_arg()(va_list apx, TypeInfo ti, void* parmn) 
     245    { 
     246        __va_list* ap = cast(__va_list*)apx; 
     247        TypeInfo arg1, arg2; 
     248        if (!ti.argTypes(arg1, arg2)) 
     249        { 
     250            if (arg1 && arg1.tsize() <= 8) 
     251            { 
     252                debug(PRINTF) printf("va_arg if branch\n"); 
     253                // Arg is passed in one register 
     254                auto tsize = arg1.tsize(); 
     255                void* p; 
     256                auto s = arg1.toString(); 
     257                if (s == "double" || s == "float") 
     258                {   // Passed in XMM register 
     259                    if (ap.offset_fpregs < (6 * 8 + 16 * 8)) 
     260                    { 
     261                        p = ap.reg_args + ap.offset_fpregs; 
     262                        ap.offset_fpregs += 16; 
     263                    } 
     264                    else 
     265                    { 
     266                        p = ap.stack_args; 
     267                        ap.stack_args += (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1); 
     268                    } 
     269                } 
     270                else 
     271                {   // Passed in regular register 
     272                    if (ap.offset_regs < 6 * 8) 
     273                    { 
     274                        p = ap.reg_args + ap.offset_regs; 
     275                        ap.offset_regs += 8; 
     276                    } 
     277                    else 
     278                    { 
     279                        p = ap.stack_args; 
     280                        ap.stack_args += 8; 
     281                    } 
     282                } 
     283                parmn[0..tsize] = p[0..tsize]; 
     284 
     285                if (arg2) 
     286                { 
     287                    parmn += 8; 
     288                    tsize = arg2.tsize(); 
     289                    s = arg2.toString(); 
     290                    if (s == "double" || s == "float") 
     291                    {   // Passed in XMM register 
     292                        if (ap.offset_fpregs < (6 * 8 + 16 * 8)) 
     293                        { 
     294                            p = ap.reg_args + ap.offset_fpregs; 
     295                            ap.offset_fpregs += 16; 
     296                        } 
     297                        else 
     298                        { 
     299                            p = ap.stack_args; 
     300                            ap.stack_args += (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1); 
     301                        } 
     302                    } 
     303                    else 
     304                    {   // Passed in regular register 
     305                        if (ap.offset_regs < 6 * 8) 
     306                        { 
     307                            p = ap.reg_args + ap.offset_regs; 
     308                            ap.offset_regs += 8; 
     309                        } 
     310                        else 
     311                        { 
     312                            p = ap.stack_args; 
     313                            ap.stack_args += 8; 
     314                        } 
     315                    } 
     316                    tsize = ti.tsize() - 8; 
     317                    parmn[0..tsize] = p[0..tsize]; 
     318                } 
     319            } 
     320            else 
     321            { 
     322                debug(PRINTF) printf("va_arg else branch\n"); 
     323                // Always passed in memory 
     324                // The arg may have more strict alignment than the stack 
     325                auto talign = ti.talign(); 
     326                auto tsize = ti.tsize(); 
     327 
     328                debug(PRINTF) printf("talign: %i, tsize: %i", talign, tsize); 
     329 
     330                auto p = cast(void*)((cast(size_t)ap.stack_args + talign - 1) & ~(talign - 1)); 
     331                ap.stack_args = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1))); 
     332                parmn[0..tsize] = p[0..tsize]; 
     333            } 
     334        } 
     335        else 
     336        { 
     337            assert(0, "not a valid argument type for va_arg"); 
     338        } 
     339    } 
     340 
     341    void va_end(va_list ap) 
     342    { 
     343    } 
     344 
    47345    void va_copy( out va_list dest, va_list src ) 
    48346    { 
    49347        dest = src; 
    50348    } 
    51349} 
     350else 
     351{ 
     352    static assert(0); 
     353} 
     354} 

  • tango/util/log/Log.d

    old new  
    103103        alias void* Arg; 
    104104        alias va_list ArgList; 
    105105        } 
     106version (DigitalMars) 
     107        { 
     108        private import tango.core.Vararg; 
     109        alias void* Arg; 
     110        alias va_list ArgList; 
     111        } 
    106112     else 
    107113        { 
    108114        alias void* Arg; 
Roadmap Timeline Tickets New Ticket Help / Guide About Trac
Login  |  
Trac dsource.org
RSS
Copyright © 2006-2024 Tango. All Rights Reserved. | Page Width: Static or Dynamic