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

Changeset 773

Show
Ignore:
Timestamp:
12/04/10 04:54:06 (14 years ago)
Author:
walter
Message:

more of Brad's bugs

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/dmd-1.x/src/backend/cgcod.c

    r768 r773  
    16391639#endif 
    16401640    int i = 0; 
    16411641    while (1) 
    16421642    { 
    16431643        if (!(regm & 0xF)) 
    16441644        { 
    16451645            regm >>= 4; 
    16461646            i += 4; 
    16471647            if (!regm) 
    16481648                break; 
    16491649        } 
    16501650        if (regm & 1) 
    16511651            return i; 
    16521652        regm >>= 1; 
    16531653        i++; 
    16541654    } 
    16551655#ifdef DEBUG 
    16561656  printf("findreg(x%x, line=%d, file='%s')\n",regmsave,line,file); 
    16571657  fflush(stdout); 
    16581658#endif 
     1659*(char*)0=0; 
    16591660  assert(0); 
    16601661  return 0; 
    16611662} 
    16621663 
    16631664 
    16641665/*************** 
    16651666 * Free element (but not it's leaves! (assume they are already freed)) 
    16661667 * Don't decrement Ecount! This is so we can detect if the common subexp 
    16671668 * has already been evaluated. 
    16681669 * If common subexpression is not required anymore, eliminate 
    16691670 * references to it. 
    16701671 */ 
    16711672 
    16721673void freenode(elem *e) 
    16731674{ unsigned i; 
    16741675 
    16751676  elem_debug(e); 
    16761677  //dbg_printf("freenode(%p) : comsub = %d, count = %d\n",e,e->Ecomsub,e->Ecount); 
    16771678  if (e->Ecomsub--) return;             /* usage count                  */ 
    16781679  if (e->Ecount)                        /* if it was a CSE              */ 
    …… 
    18001801 */ 
    18011802 
    18021803#undef allocreg 
    18031804 
    18041805code *allocreg(regm_t *pretregs,unsigned *preg,tym_t tym 
    18051806#ifdef DEBUG 
    18061807        ,int line,const char *file 
    18071808#endif 
    18081809        ) 
    18091810#ifdef DEBUG 
    18101811#define allocreg(a,b,c) allocreg((a),(b),(c),__LINE__,__FILE__) 
    18111812#endif 
    18121813{       regm_t r,s; 
    18131814        regm_t retregs; 
    18141815        unsigned reg; 
    18151816        unsigned msreg,lsreg; 
    18161817        int count; 
    18171818        unsigned size; 
    18181819 
    18191820#if 0 
    1820 //      if (pass == PASSfinal) 
     1821      if (pass == PASSfinal) 
    18211822        {   dbg_printf("allocreg %s,%d: regcon.mvar %s regcon.cse.mval %s msavereg %s *pretregs %s tym ", 
    18221823                file,line,regm_str(regcon.mvar),regm_str(regcon.cse.mval), 
    18231824                regm_str(msavereg),regm_str(*pretregs)); 
    18241825            WRTYxx(tym); 
    18251826            dbg_printf("\n"); 
    18261827        } 
    18271828#endif 
    18281829        tym = tybasic(tym); 
    18291830        size = tysize[tym]; 
    18301831        *pretregs &= mES | allregs | XMMREGS; 
    18311832        retregs = *pretregs; 
    18321833        if ((retregs & regcon.mvar) == retregs) // if exactly in reg vars 
    18331834        { 
    18341835            if (size <= REGSIZE) 
    18351836            {   *preg = findreg(retregs); 
    18361837                assert(retregs == mask[*preg]); /* no more bits are set */ 
    18371838            } 
    18381839            else if (size <= 2 * REGSIZE) 
    18391840            {   *preg = findregmsw(retregs); 
    18401841                assert(retregs & mLSW); 
    …… 
    19091910            {   retregs &= ~mBP; 
    19101911                goto L3; 
    19111912            } 
    19121913 
    19131914            if (r & mMSW) 
    19141915            { 
    19151916                if (r & mDX) 
    19161917                    msreg = DX;                 /* prefer to use DX over CX */ 
    19171918                else 
    19181919                    msreg = findregmsw(r); 
    19191920                r &= mLSW;                      /* see if there's an LSW also */ 
    19201921                if (r) 
    19211922                    lsreg = findreg(r); 
    19221923                else if (lsreg == -1)   /* if don't have LSW yet */ 
    19231924                {       retregs &= mLSW; 
    19241925                    goto L3; 
    19251926                } 
    19261927            } 
    19271928            else 
    19281929            { 
     1930                if (I64 && !(r & mLSW)) 
     1931                {   retregs = *pretregs & (mMSW | mLSW); 
     1932                    assert(retregs); 
     1933                    goto L1; 
     1934                } 
    19291935                lsreg = findreglsw(r); 
    19301936                if (msreg == -1) 
    19311937                {   retregs &= mMSW; 
    19321938                    goto L3; 
    19331939                } 
    19341940            } 
    19351941            reg = (msreg == ES) ? lsreg : msreg; 
    19361942            retregs = mask[msreg] | mask[lsreg]; 
    19371943        } 
    19381944        else if (I16 && (tym == TYdouble || tym == TYdouble_alias)) 
    19391945        { 
    19401946#ifdef DEBUG 
    19411947            if (retregs != DOUBLEREGS) 
    19421948                printf("retregs = x%x, *pretregs = x%x\n",retregs,*pretregs); 
    19431949#endif 
    19441950            assert(retregs == DOUBLEREGS); 
    19451951            reg = AX; 
    19461952        } 
    19471953        else 
    19481954        { 

  • branches/dmd-1.x/src/backend/cgelem.c

    r767 r773  
    29882988            (e2->E1->Eoper == OPvar || e2->E1->Eoper == OPind)) 
    29892989        {   elem *es; 
    29902990            tym_t ty; 
    29912991 
    29922992            es = el_calloc(); 
    29932993            es->Eoper = OPconst; 
    29942994            switch (tysize(e2->Ety)) 
    29952995            { 
    29962996                case FLOATSIZE: 
    29972997                    ty = TYlong; 
    29982998                    es->EV.Vlong = 0x80000000; 
    29992999                    break; 
    30003000                case DOUBLESIZE: 
    30013001#if LONGLONG 
    30023002                    if (I32) 
    30033003                    {   ty = TYllong; 
    30043004                        es->EV.Vllong = 0x8000000000000000LL; 
    30053005                        break; 
    30063006                    } 
    30073007#endif 
    3008                 case LNGDBLSIZE: 
     3008                default: 
    30093009                    el_free(es); 
    30103010                    goto L8; 
    30113011            } 
    30123012            es->Ety = ty; 
    30133013            e1->Ety = ty; 
    30143014            e2->Ety = ty; 
    30153015            e2->E1->Ety = ty; 
    30163016            e2->E2 = es; 
    30173017            e2->Eoper = OPxor; 
    30183018            return optelem(e,TRUE); 
    30193019        } 
    30203020    L8: ; 
    30213021    } 
    30223022 
    30233023   if (e1->Eoper == OPcomma) 
    30243024        return cgel_lvalue(e); 
    30253025#if MARS 
    30263026    // No bit fields to deal with 
    30273027    return e; 
    30283028#else 

  • branches/dmd-1.x/src/backend/debug.c

    r728 r773  
    193193        {       nest++; 
    194194                ferr("("); 
    195195                WReqn(e->E2); 
    196196                ferr(")"); 
    197197                nest--; 
    198198        } 
    199199        else 
    200200                WReqn(e->E2); 
    201201  } 
    202202  else 
    203203  { 
    204204        switch (e->Eoper) 
    205205        {   case OPconst: 
    206206                switch (tybasic(e->Ety)) 
    207207                { 
    208208                    case TYfloat: 
    209209                        dbg_printf("%g <float> ",e->EV.Vfloat); 
    210210                        break; 
    211211                    case TYdouble: 
    212212                        dbg_printf("%g ",e->EV.Vdouble); 
     213                        break; 
     214                    case TYldouble: 
     215                        dbg_printf("%Lg ",e->EV.Vldouble); 
    213216                        break; 
    214217                    case TYcent: 
    215218                    case TYucent: 
    216219                        dbg_printf("%lld+%lld ", e->EV.Vcent.msw, e->EV.Vcent.lsw); 
    217220                        break; 
    218221                    default: 
    219222                        dbg_printf("%lld ",el_tolong(e)); 
    220223                        break; 
    221224                } 
    222225                break; 
    223226            case OPrelconst: 
    224227                ferr("#"); 
    225228                /* FALL-THROUGH */ 
    226229            case OPvar: 
    227230                dbg_printf("%s",e->EV.sp.Vsym->Sident); 
    228231                if (e->EV.sp.Vsym->Ssymnum != -1) 
    229232                    dbg_printf("(%d)",e->EV.sp.Vsym->Ssymnum); 
    230233                if (e->Eoffset != 0) 
    231234                        dbg_printf(".%ld",(long)e->Eoffset); 
    232235                break; 

  • branches/dmd-1.x/src/backend/el.c

    r771 r773  
    33503350#if TARGET_MAC 
    33513351#if (TARGET_POWERPC) 
    33523352                        if (config.flags & CFGldblisdbl) 
    33533353                            dbg_printf("%gL ",e->EV.Vdouble); 
    33543354                        else 
    33553355#endif 
    33563356#if !DDRT 
    33573357                            dbg_printf("%LgL ",e->EV.Vldouble); 
    33583358#else /* DDRT */ 
    33593359                        { 
    33603360                            static char buffer[75]; 
    33613361                            __g_fmt(buffer, (DD)e->EV.Vldouble); 
    33623362                            dbg_printf("%sL", buffer); 
    33633363                        } 
    33643364#endif /* DDRT */ 
    33653365                        break; 
    33663366                    case TYvptr: 
    33673367                        dbg_printf("%ldL ",e->EV.Vlong); 
    33683368                        break; 
    33693369#else 
    3370                         dbg_printf("%gL ",(double)e->EV.Vldouble); 
     3370                        dbg_printf("%Lg ", e->EV.Vldouble); 
    33713371#endif 
    33723372                        break; 
    33733373 
    33743374                    case TYifloat: 
    33753375                        dbg_printf("%gfi ", (double)e->EV.Vfloat); 
    33763376                        break; 
    33773377 
    33783378                    case TYidouble: 
    33793379                        dbg_printf("%gi ", (double)e->EV.Vdouble); 
    33803380                        break; 
    33813381 
    33823382                    case TYildouble: 
    33833383                        dbg_printf("%gLi ", (double)e->EV.Vldouble); 
    33843384                        break; 
    33853385 
    33863386                    case TYcfloat: 
    33873387                        dbg_printf("%gf+%gfi ", (double)e->EV.Vcfloat.re, (double)e->EV.Vcfloat.im); 
    33883388                        break; 
    33893389 
    33903390                    case TYcdouble: 

  • trunk/src/backend/cgcod.c

    r768 r773  
    16391639#endif 
    16401640    int i = 0; 
    16411641    while (1) 
    16421642    { 
    16431643        if (!(regm & 0xF)) 
    16441644        { 
    16451645            regm >>= 4; 
    16461646            i += 4; 
    16471647            if (!regm) 
    16481648                break; 
    16491649        } 
    16501650        if (regm & 1) 
    16511651            return i; 
    16521652        regm >>= 1; 
    16531653        i++; 
    16541654    } 
    16551655#ifdef DEBUG 
    16561656  printf("findreg(x%x, line=%d, file='%s')\n",regmsave,line,file); 
    16571657  fflush(stdout); 
    16581658#endif 
     1659*(char*)0=0; 
    16591660  assert(0); 
    16601661  return 0; 
    16611662} 
    16621663 
    16631664 
    16641665/*************** 
    16651666 * Free element (but not it's leaves! (assume they are already freed)) 
    16661667 * Don't decrement Ecount! This is so we can detect if the common subexp 
    16671668 * has already been evaluated. 
    16681669 * If common subexpression is not required anymore, eliminate 
    16691670 * references to it. 
    16701671 */ 
    16711672 
    16721673void freenode(elem *e) 
    16731674{ unsigned i; 
    16741675 
    16751676  elem_debug(e); 
    16761677  //dbg_printf("freenode(%p) : comsub = %d, count = %d\n",e,e->Ecomsub,e->Ecount); 
    16771678  if (e->Ecomsub--) return;             /* usage count                  */ 
    16781679  if (e->Ecount)                        /* if it was a CSE              */ 
    …… 
    18001801 */ 
    18011802 
    18021803#undef allocreg 
    18031804 
    18041805code *allocreg(regm_t *pretregs,unsigned *preg,tym_t tym 
    18051806#ifdef DEBUG 
    18061807        ,int line,const char *file 
    18071808#endif 
    18081809        ) 
    18091810#ifdef DEBUG 
    18101811#define allocreg(a,b,c) allocreg((a),(b),(c),__LINE__,__FILE__) 
    18111812#endif 
    18121813{       regm_t r,s; 
    18131814        regm_t retregs; 
    18141815        unsigned reg; 
    18151816        unsigned msreg,lsreg; 
    18161817        int count; 
    18171818        unsigned size; 
    18181819 
    18191820#if 0 
    1820 //      if (pass == PASSfinal) 
     1821      if (pass == PASSfinal) 
    18211822        {   dbg_printf("allocreg %s,%d: regcon.mvar %s regcon.cse.mval %s msavereg %s *pretregs %s tym ", 
    18221823                file,line,regm_str(regcon.mvar),regm_str(regcon.cse.mval), 
    18231824                regm_str(msavereg),regm_str(*pretregs)); 
    18241825            WRTYxx(tym); 
    18251826            dbg_printf("\n"); 
    18261827        } 
    18271828#endif 
    18281829        tym = tybasic(tym); 
    18291830        size = tysize[tym]; 
    18301831        *pretregs &= mES | allregs | XMMREGS; 
    18311832        retregs = *pretregs; 
    18321833        if ((retregs & regcon.mvar) == retregs) // if exactly in reg vars 
    18331834        { 
    18341835            if (size <= REGSIZE) 
    18351836            {   *preg = findreg(retregs); 
    18361837                assert(retregs == mask[*preg]); /* no more bits are set */ 
    18371838            } 
    18381839            else if (size <= 2 * REGSIZE) 
    18391840            {   *preg = findregmsw(retregs); 
    18401841                assert(retregs & mLSW); 
    …… 
    19091910            {   retregs &= ~mBP; 
    19101911                goto L3; 
    19111912            } 
    19121913 
    19131914            if (r & mMSW) 
    19141915            { 
    19151916                if (r & mDX) 
    19161917                    msreg = DX;                 /* prefer to use DX over CX */ 
    19171918                else 
    19181919                    msreg = findregmsw(r); 
    19191920                r &= mLSW;                      /* see if there's an LSW also */ 
    19201921                if (r) 
    19211922                    lsreg = findreg(r); 
    19221923                else if (lsreg == -1)   /* if don't have LSW yet */ 
    19231924                {       retregs &= mLSW; 
    19241925                    goto L3; 
    19251926                } 
    19261927            } 
    19271928            else 
    19281929            { 
     1930                if (I64 && !(r & mLSW)) 
     1931                {   retregs = *pretregs & (mMSW | mLSW); 
     1932                    assert(retregs); 
     1933                    goto L1; 
     1934                } 
    19291935                lsreg = findreglsw(r); 
    19301936                if (msreg == -1) 
    19311937                {   retregs &= mMSW; 
    19321938                    goto L3; 
    19331939                } 
    19341940            } 
    19351941            reg = (msreg == ES) ? lsreg : msreg; 
    19361942            retregs = mask[msreg] | mask[lsreg]; 
    19371943        } 
    19381944        else if (I16 && (tym == TYdouble || tym == TYdouble_alias)) 
    19391945        { 
    19401946#ifdef DEBUG 
    19411947            if (retregs != DOUBLEREGS) 
    19421948                printf("retregs = x%x, *pretregs = x%x\n",retregs,*pretregs); 
    19431949#endif 
    19441950            assert(retregs == DOUBLEREGS); 
    19451951            reg = AX; 
    19461952        } 
    19471953        else 
    19481954        { 

  • trunk/src/backend/cgelem.c

    r767 r773  
    29882988            (e2->E1->Eoper == OPvar || e2->E1->Eoper == OPind)) 
    29892989        {   elem *es; 
    29902990            tym_t ty; 
    29912991 
    29922992            es = el_calloc(); 
    29932993            es->Eoper = OPconst; 
    29942994            switch (tysize(e2->Ety)) 
    29952995            { 
    29962996                case FLOATSIZE: 
    29972997                    ty = TYlong; 
    29982998                    es->EV.Vlong = 0x80000000; 
    29992999                    break; 
    30003000                case DOUBLESIZE: 
    30013001#if LONGLONG 
    30023002                    if (I32) 
    30033003                    {   ty = TYllong; 
    30043004                        es->EV.Vllong = 0x8000000000000000LL; 
    30053005                        break; 
    30063006                    } 
    30073007#endif 
    3008                 case LNGDBLSIZE: 
     3008                default: 
    30093009                    el_free(es); 
    30103010                    goto L8; 
    30113011            } 
    30123012            es->Ety = ty; 
    30133013            e1->Ety = ty; 
    30143014            e2->Ety = ty; 
    30153015            e2->E1->Ety = ty; 
    30163016            e2->E2 = es; 
    30173017            e2->Eoper = OPxor; 
    30183018            return optelem(e,TRUE); 
    30193019        } 
    30203020    L8: ; 
    30213021    } 
    30223022 
    30233023   if (e1->Eoper == OPcomma) 
    30243024        return cgel_lvalue(e); 
    30253025#if MARS 
    30263026    // No bit fields to deal with 
    30273027    return e; 
    30283028#else 

  • trunk/src/backend/debug.c

    r728 r773  
    193193        {       nest++; 
    194194                ferr("("); 
    195195                WReqn(e->E2); 
    196196                ferr(")"); 
    197197                nest--; 
    198198        } 
    199199        else 
    200200                WReqn(e->E2); 
    201201  } 
    202202  else 
    203203  { 
    204204        switch (e->Eoper) 
    205205        {   case OPconst: 
    206206                switch (tybasic(e->Ety)) 
    207207                { 
    208208                    case TYfloat: 
    209209                        dbg_printf("%g <float> ",e->EV.Vfloat); 
    210210                        break; 
    211211                    case TYdouble: 
    212212                        dbg_printf("%g ",e->EV.Vdouble); 
     213                        break; 
     214                    case TYldouble: 
     215                        dbg_printf("%Lg ",e->EV.Vldouble); 
    213216                        break; 
    214217                    case TYcent: 
    215218                    case TYucent: 
    216219                        dbg_printf("%lld+%lld ", e->EV.Vcent.msw, e->EV.Vcent.lsw); 
    217220                        break; 
    218221                    default: 
    219222                        dbg_printf("%lld ",el_tolong(e)); 
    220223                        break; 
    221224                } 
    222225                break; 
    223226            case OPrelconst: 
    224227                ferr("#"); 
    225228                /* FALL-THROUGH */ 
    226229            case OPvar: 
    227230                dbg_printf("%s",e->EV.sp.Vsym->Sident); 
    228231                if (e->EV.sp.Vsym->Ssymnum != -1) 
    229232                    dbg_printf("(%d)",e->EV.sp.Vsym->Ssymnum); 
    230233                if (e->Eoffset != 0) 
    231234                        dbg_printf(".%ld",(long)e->Eoffset); 
    232235                break; 

  • trunk/src/backend/el.c

    r771 r773  
    33503350#if TARGET_MAC 
    33513351#if (TARGET_POWERPC) 
    33523352                        if (config.flags & CFGldblisdbl) 
    33533353                            dbg_printf("%gL ",e->EV.Vdouble); 
    33543354                        else 
    33553355#endif 
    33563356#if !DDRT 
    33573357                            dbg_printf("%LgL ",e->EV.Vldouble); 
    33583358#else /* DDRT */ 
    33593359                        { 
    33603360                            static char buffer[75]; 
    33613361                            __g_fmt(buffer, (DD)e->EV.Vldouble); 
    33623362                            dbg_printf("%sL", buffer); 
    33633363                        } 
    33643364#endif /* DDRT */ 
    33653365                        break; 
    33663366                    case TYvptr: 
    33673367                        dbg_printf("%ldL ",e->EV.Vlong); 
    33683368                        break; 
    33693369#else 
    3370                         dbg_printf("%gL ",(double)e->EV.Vldouble); 
     3370                        dbg_printf("%Lg ", e->EV.Vldouble); 
    33713371#endif 
    33723372                        break; 
    33733373 
    33743374                    case TYifloat: 
    33753375                        dbg_printf("%gfi ", (double)e->EV.Vfloat); 
    33763376                        break; 
    33773377 
    33783378                    case TYidouble: 
    33793379                        dbg_printf("%gi ", (double)e->EV.Vdouble); 
    33803380                        break; 
    33813381 
    33823382                    case TYildouble: 
    33833383                        dbg_printf("%gLi ", (double)e->EV.Vldouble); 
    33843384                        break; 
    33853385 
    33863386                    case TYcfloat: 
    33873387                        dbg_printf("%gf+%gfi ", (double)e->EV.Vcfloat.re, (double)e->EV.Vcfloat.im); 
    33883388                        break; 
    33893389 
    33903390                    case TYcdouble: