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

Changeset 771

Show
Ignore:
Timestamp:
12/02/10 23:37:26 (14 years ago)
Author:
walter
Message:

more 64

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r770 r771  
    630630                            !(i == DX && op == 0xF7 && desmsk & mDX)) 
    631631                        { 
    632632                                /* if ES, then it can only be a load    */ 
    633633                                if (i == ES) 
    634634                                {       if (op != 0x8B) 
    635635                                            goto L1;    /* not a load   */ 
    636636                                        cs->Iop = 0x8C; /* MOV reg,ES   */ 
    637637                                        cs->Irm = modregrm(3,0,reg & 7); 
    638638                                        if (reg & 8) 
    639639                                            code_orrex(cs, REX_B); 
    640640                                } 
    641641                                else    // XXX reg,i 
    642642                                { 
    643643                                    cs->Irm = modregrm(3,reg & 7,i & 7); 
    644644                                    if (reg & 8) 
    645645                                        cs->Irex |= REX_R; 
    646646                                    if (i & 8) 
    647647                                        cs->Irex |= REX_B; 
    648648                                    if (sz == 1 && I64 && i >= 4) 
    649649                                        cs->Irex |= REX; 
     650                                    if (I64 && (sz == 8 || sz == 16)) 
     651                                        cs->Irex |= REX_W; 
    650652                                } 
    651653                                c = CNIL; 
    652654                                goto L2; 
    653655                        } 
    654656                        rm &= ~mask[i]; 
    655657                } 
    656658        } 
    657659  } 
    658660 
    659661L1: 
    660662  c = getlvalue(cs,e,keepmsk); 
    661663  if (offset == REGSIZE) 
    662664        getlvalue_msw(cs); 
    663665  else 
    664666        cs->IEVoffset1 += offset; 
    665667  if (I64 && reg >= 4 && sz == 1)               // if byte register 
    666668        // Can only address those 8 bit registers if a REX byte is present 
    667669        cs->Irex |= REX; 
    668670  code_newreg(cs, reg);                         // OR in reg field 
    669671  if (!I16) 

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

    r768 r771  
    37623762            if (s->ty() & mTYcs) 
    37633763                fl = FLcsdata; 
    37643764            c = gen2(c,0x8C,            /* MOV mreg,SEG REGISTER        */ 
    37653765                modregrm(3,segfl[fl],mreg)); 
    37663766        } 
    37673767        if (*pretregs & mES) 
    37683768                gen2(c,0x8E,modregrm(3,0,mreg));        /* MOV ES,mreg  */ 
    37693769  } 
    37703770  return cat(c,getoffset(e,lreg)); 
    37713771} 
    37723772 
    37733773/********************************* 
    37743774 * Load the offset portion of the address represented by e into 
    37753775 * reg. 
    37763776 */ 
    37773777 
    37783778code *getoffset(elem *e,unsigned reg) 
    37793779{ code cs; 
    37803780  code *c; 
    37813781 
     3782  //printf("getoffset(e = %p, reg = %d)\n", e, reg); 
    37823783  cs.Iflags = 0; 
    37833784  unsigned char rex = 0; 
    37843785  cs.Irex = rex; 
    37853786  assert(e->Eoper == OPvar || e->Eoper == OPrelconst); 
    37863787  enum FL fl = el_fl(e); 
    37873788  switch (fl) 
    37883789  { 
    37893790    case FLdatseg: 
    37903791        cs.IEV2._EP.Vpointer = e->EV.Vpointer; 
    37913792        goto L3; 
    37923793 
    37933794    case FLfardata: 
    37943795        assert(!TARGET_FLAT); 
    37953796        goto L4; 
    37963797 
    37973798    case FLtlsdata: 
    37983799#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS 
    37993800    { 
    38003801      L5: 
    38013802        if (I64 && config.flags3 & CFG3pic) 
    …… 
    39003901    case FLcsdata: 
    39013902    L4: 
    39023903        cs.IEVsym2 = e->EV.sp.Vsym; 
    39033904        cs.IEVoffset2 = e->EV.sp.Voffset; 
    39043905    L3: 
    39053906        if (reg == STACK) 
    39063907        {   stackchanged = 1; 
    39073908            cs.Iop = 0x68;              /* PUSH immed16                 */ 
    39083909            c = genadjesp(NULL,REGSIZE); 
    39093910        } 
    39103911        else 
    39113912        {   cs.Iop = 0xB8 + (reg & 7);  // MOV reg,immed16 
    39123913            if (reg & 8) 
    39133914                cs.Irex |= REX_B; 
    39143915            if (I64) 
    39153916            {   cs.Irex |= REX_W; 
    39163917                if (config.flags3 & CFG3pic) 
    39173918                {   // LEA reg,immed32[RIP] 
    39183919                    cs.Iop = 0x8D; 
    39193920                    cs.Irm = modregrm(0,reg & 7,5); 
     3921                    if (reg & 8) 
     3922                        cs.Irex = (cs.Irex & ~REX_B) | REX_R; 
    39203923                    cs.IFL1 = fl; 
    39213924                    cs.IEVsym1 = cs.IEVsym2; 
    39223925                    cs.IEVoffset1 = cs.IEVoffset2; 
    39233926                } 
    39243927            } 
    39253928            c = NULL; 
    39263929        } 
    39273930        cs.Iflags = CFoff;              /* want offset only             */ 
    39283931        cs.IFL2 = fl; 
    39293932        c = gen(c,&cs); 
    39303933        break; 
    39313934 
    39323935#if 0 && TARGET_LINUX 
    39333936    case FLgot: 
    39343937    case FLgotoff: 
    39353938        { 
    39363939        gotref = 1; 
    39373940        symbol *s = e->EV.sp.Vsym; 
    39383941        // When using 8B (MOV), indicating that rm is used 
    39393942        // rm operands are always placed in IEV1 not IEV2 

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

    r768 r771  
    52085208} 
    52095209 
    52105210void code::print() 
    52115211{ 
    52125212    unsigned char ins; 
    52135213    code *c = this; 
    52145214 
    52155215    if (c == CNIL) 
    52165216    {   printf("code 0\n"); 
    52175217        return; 
    52185218    } 
    52195219 
    52205220    unsigned op = c->Iop; 
    52215221    if ((c->Iop & 0xFF00) == 0x0F00) 
    52225222        ins = inssize2[op & 0xFF]; 
    52235223    else 
    52245224        ins = inssize[op & 0xFF]; 
    52255225 
    52265226    printf("code %p: nxt=%p ",c,code_next(c)); 
    52275227    if (c->Irex) 
    5228         printf("rex=%x ", c->Irex); 
     5228    {   printf("rex=%x ", c->Irex); 
     5229        if (c->Irex & REX_W) 
     5230            printf("W"); 
     5231        if (c->Irex & REX_R) 
     5232            printf("R"); 
     5233        if (c->Irex & REX_X) 
     5234            printf("X"); 
     5235        if (c->Irex & REX_B) 
     5236            printf("B"); 
     5237        printf(" "); 
     5238    } 
    52295239    printf("op=%02x",op); 
    52305240 
    52315241  if ((op & 0xFF) == ESCAPE) 
    52325242  {     if ((op & 0xFF00) == ESClinnum) 
    52335243        {   printf(" linnum = %d\n",c->IEV2.Vsrcpos.Slinnum); 
    52345244            return; 
    52355245        } 
    52365246        printf(" ESCAPE %d",c->Iop >> 8); 
    52375247  } 
    52385248  if (c->Iflags) 
    52395249        printf(" flg=%x",c->Iflags); 
    52405250  if (ins & M) 
    52415251  {     unsigned rm = c->Irm; 
    52425252        printf(" rm=%02x=%d,%d,%d",rm,(rm>>6)&3,(rm>>3)&7,rm&7); 
    52435253        if (!I16 && issib(rm)) 
    52445254        {   unsigned char sib = c->Isib; 
    52455255            printf(" sib=%02x=%d,%d,%d",sib,(sib>>6)&3,(sib>>3)&7,sib&7); 
    52465256        } 
    52475257        if ((rm & 0xC7) == BPRM || (rm & 0xC0) == 0x80 || (rm & 0xC0) == 0x40) 
    52485258        { 

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

    r768 r771  
    19741974        {       cl = getlvalue(&cs,e1,RMload); 
    19751975                freenode(e1); 
    19761976                if (evalinregister(e2)) 
    19771977                { 
    19781978                    retregs = idxregm(&cs); 
    19791979                    if ((cs.Iflags & CFSEG) == CFes) 
    19801980                            retregs |= mES;             /* take no chances */ 
    19811981                    rretregs = allregs & ~retregs; 
    19821982                    if (byte) 
    19831983                            rretregs &= BYTEREGS; 
    19841984                    cr = scodelem(e2,&rretregs,retregs,TRUE); 
    19851985                    cs.Iop = 0x39 ^ byte ^ reverse; 
    19861986                    if (sz > REGSIZE) 
    19871987                    { 
    19881988                        rreg = findregmsw(rretregs); 
    19891989                        cs.Irm |= modregrm(0,rreg,0); 
    19901990                        getlvalue_msw(&cs); 
    19911991                        c = gen(CNIL,&cs);              /* CMP EA+2,rreg */ 
    19921992                        if (I32 && sz == 6) 
    19931993                            c->Iflags |= CFopsize;      /* seg is only 16 bits  */ 
     1994                        if (I64 && byte && rreg >= 4) 
     1995                            c->Irex |= REX; 
    19941996                        genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop   */ 
    19951997                        rreg = findreglsw(rretregs); 
    19961998                        NEWREG(cs.Irm,rreg); 
    19971999                        getlvalue_lsw(&cs); 
    19982000                    } 
    19992001                    else 
    20002002                    { 
    20012003                        rreg = findreg(rretregs); 
    20022004                        code_newreg(&cs, rreg); 
     2005                        if (I64 && byte && rreg >= 4) 
     2006                            cs.Irex |= REX; 
    20032007                    } 
    20042008                } 
    20052009                else 
    20062010                { 
    20072011                    cs.Irm |= modregrm(0,7,0); 
    20082012                    if (sz > REGSIZE) 
    20092013                    { 
    20102014#if TARGET_FLAT 
    20112015                        if (sz == 6) 
    20122016                            assert(0); 
    20132017#endif 
    20142018                        if (e2->Eoper == OPrelconst) 
    20152019                        {   cs.Iflags = (cs.Iflags & ~(CFoff | CFseg)) | CFseg; 
    20162020                            cs.IEVoffset2 = 0; 
    20172021                        } 
    20182022                        getlvalue_msw(&cs); 
    20192023                        c = gen(CNIL,&cs);              /* CMP EA+2,const */ 
    20202024                        if (!I16 && sz == 6) 
    20212025                            c->Iflags |= CFopsize;      /* seg is only 16 bits  */ 
    20222026                        genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop   */ 

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

    r768 r771  
    29582958        case TYdouble: 
    29592959        case TYfloat: 
    29602960        case TYildouble: 
    29612961        case TYidouble: 
    29622962        case TYifloat: 
    29632963        case TYcldouble: 
    29642964        case TYcdouble: 
    29652965        case TYcfloat: 
    29662966#if !DDRT 
    29672967            result = (targ_llong)el_toldouble(e); 
    29682968#else 
    29692969            result = Xxtoi(el_toldouble(e)); 
    29702970#endif 
    29712971            break; 
    29722972 
    29732973#if SCPP 
    29742974        case TYmemptr: 
    29752975            ty = tybasic(tym_conv(e->ET)); 
    29762976            goto L1; 
    29772977#endif 
     2978 
     2979        case TYcent: 
     2980        case TYucent: 
     2981            goto Ullong; // should do better than this when actually doing arithmetic on cents 
     2982 
    29782983        default: 
    29792984#if SCPP 
    29802985            // Can happen as result of syntax errors 
    29812986            assert(errcnt); 
    29822987#else 
    29832988#ifdef DEBUG 
    29842989            elem_print(e); 
    29852990            *(char*)0=0; 
    29862991#endif 
    29872992            assert(0); 
    29882993#endif 
    29892994    } 
    29902995    return result; 
    29912996} 
    29922997 
    29932998/*********************************** 
    29942999 * Determine if constant e is all ones or all zeros. 
    29953000 * Input: 
    29963001 *      bit 0:  all zeros 
    29973002 *          1:  1 

  • branches/dmd-1.x/src/iasm.c

    r714 r771  
    893893 
    894894STATIC opflag_t asm_determine_float_flags(OPND *popnd) 
    895895{ 
    896896    //printf("asm_determine_float_flags()\n"); 
    897897 
    898898    opflag_t us, usFloat; 
    899899 
    900900    // Insure that if it is a register, that it is not a normal processor 
    901901    // register. 
    902902 
    903903    if (popnd->base && 
    904904            !popnd->s && !popnd->disp && !popnd->real 
    905905            && !(popnd->base->ty & (_r8 | _r16 | _r32))) 
    906906    { 
    907907        return popnd->base->ty; 
    908908    } 
    909909    if (popnd->pregDisp1 && !popnd->base) 
    910910    { 
    911911        us = asm_float_type_size(popnd->ptype, &usFloat); 
    912912        //printf("us = x%x, usFloat = x%x\n", us, usFloat); 
    913         if (popnd->pregDisp1->ty & _r32) 
     913        if (popnd->pregDisp1->ty & (_r32 | _r64)) 
    914914            return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat)); 
    915915        else 
    916916        if (popnd->pregDisp1->ty & _r16) 
    917917            return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat)); 
    918918    } 
    919919    else if (popnd->s != 0) 
    920920    { 
    921921        us = asm_float_type_size(popnd->ptype, &usFloat); 
    922922        return CONSTRUCT_FLAGS(us, _m, _normal, usFloat); 
    923923    } 
    924924 
    925925    if (popnd->segreg) 
    926926    { 
    927927        us = asm_float_type_size(popnd->ptype, &usFloat); 
    928928        if (I16) 
    929929            return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat)); 
    930930        else 
    931931            return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat)); 
    932932    } 
    933933 

  • trunk/src/backend/cod1.c

    r770 r771  
    630630                            !(i == DX && op == 0xF7 && desmsk & mDX)) 
    631631                        { 
    632632                                /* if ES, then it can only be a load    */ 
    633633                                if (i == ES) 
    634634                                {       if (op != 0x8B) 
    635635                                            goto L1;    /* not a load   */ 
    636636                                        cs->Iop = 0x8C; /* MOV reg,ES   */ 
    637637                                        cs->Irm = modregrm(3,0,reg & 7); 
    638638                                        if (reg & 8) 
    639639                                            code_orrex(cs, REX_B); 
    640640                                } 
    641641                                else    // XXX reg,i 
    642642                                { 
    643643                                    cs->Irm = modregrm(3,reg & 7,i & 7); 
    644644                                    if (reg & 8) 
    645645                                        cs->Irex |= REX_R; 
    646646                                    if (i & 8) 
    647647                                        cs->Irex |= REX_B; 
    648648                                    if (sz == 1 && I64 && i >= 4) 
    649649                                        cs->Irex |= REX; 
     650                                    if (I64 && (sz == 8 || sz == 16)) 
     651                                        cs->Irex |= REX_W; 
    650652                                } 
    651653                                c = CNIL; 
    652654                                goto L2; 
    653655                        } 
    654656                        rm &= ~mask[i]; 
    655657                } 
    656658        } 
    657659  } 
    658660 
    659661L1: 
    660662  c = getlvalue(cs,e,keepmsk); 
    661663  if (offset == REGSIZE) 
    662664        getlvalue_msw(cs); 
    663665  else 
    664666        cs->IEVoffset1 += offset; 
    665667  if (I64 && reg >= 4 && sz == 1)               // if byte register 
    666668        // Can only address those 8 bit registers if a REX byte is present 
    667669        cs->Irex |= REX; 
    668670  code_newreg(cs, reg);                         // OR in reg field 
    669671  if (!I16) 

  • trunk/src/backend/cod2.c

    r768 r771  
    37623762            if (s->ty() & mTYcs) 
    37633763                fl = FLcsdata; 
    37643764            c = gen2(c,0x8C,            /* MOV mreg,SEG REGISTER        */ 
    37653765                modregrm(3,segfl[fl],mreg)); 
    37663766        } 
    37673767        if (*pretregs & mES) 
    37683768                gen2(c,0x8E,modregrm(3,0,mreg));        /* MOV ES,mreg  */ 
    37693769  } 
    37703770  return cat(c,getoffset(e,lreg)); 
    37713771} 
    37723772 
    37733773/********************************* 
    37743774 * Load the offset portion of the address represented by e into 
    37753775 * reg. 
    37763776 */ 
    37773777 
    37783778code *getoffset(elem *e,unsigned reg) 
    37793779{ code cs; 
    37803780  code *c; 
    37813781 
     3782  //printf("getoffset(e = %p, reg = %d)\n", e, reg); 
    37823783  cs.Iflags = 0; 
    37833784  unsigned char rex = 0; 
    37843785  cs.Irex = rex; 
    37853786  assert(e->Eoper == OPvar || e->Eoper == OPrelconst); 
    37863787  enum FL fl = el_fl(e); 
    37873788  switch (fl) 
    37883789  { 
    37893790    case FLdatseg: 
    37903791        cs.IEV2._EP.Vpointer = e->EV.Vpointer; 
    37913792        goto L3; 
    37923793 
    37933794    case FLfardata: 
    37943795        assert(!TARGET_FLAT); 
    37953796        goto L4; 
    37963797 
    37973798    case FLtlsdata: 
    37983799#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS 
    37993800    { 
    38003801      L5: 
    38013802        if (I64 && config.flags3 & CFG3pic) 
    …… 
    39003901    case FLcsdata: 
    39013902    L4: 
    39023903        cs.IEVsym2 = e->EV.sp.Vsym; 
    39033904        cs.IEVoffset2 = e->EV.sp.Voffset; 
    39043905    L3: 
    39053906        if (reg == STACK) 
    39063907        {   stackchanged = 1; 
    39073908            cs.Iop = 0x68;              /* PUSH immed16                 */ 
    39083909            c = genadjesp(NULL,REGSIZE); 
    39093910        } 
    39103911        else 
    39113912        {   cs.Iop = 0xB8 + (reg & 7);  // MOV reg,immed16 
    39123913            if (reg & 8) 
    39133914                cs.Irex |= REX_B; 
    39143915            if (I64) 
    39153916            {   cs.Irex |= REX_W; 
    39163917                if (config.flags3 & CFG3pic) 
    39173918                {   // LEA reg,immed32[RIP] 
    39183919                    cs.Iop = 0x8D; 
    39193920                    cs.Irm = modregrm(0,reg & 7,5); 
     3921                    if (reg & 8) 
     3922                        cs.Irex = (cs.Irex & ~REX_B) | REX_R; 
    39203923                    cs.IFL1 = fl; 
    39213924                    cs.IEVsym1 = cs.IEVsym2; 
    39223925                    cs.IEVoffset1 = cs.IEVoffset2; 
    39233926                } 
    39243927            } 
    39253928            c = NULL; 
    39263929        } 
    39273930        cs.Iflags = CFoff;              /* want offset only             */ 
    39283931        cs.IFL2 = fl; 
    39293932        c = gen(c,&cs); 
    39303933        break; 
    39313934 
    39323935#if 0 && TARGET_LINUX 
    39333936    case FLgot: 
    39343937    case FLgotoff: 
    39353938        { 
    39363939        gotref = 1; 
    39373940        symbol *s = e->EV.sp.Vsym; 
    39383941        // When using 8B (MOV), indicating that rm is used 
    39393942        // rm operands are always placed in IEV1 not IEV2 

  • trunk/src/backend/cod3.c

    r768 r771  
    52085208} 
    52095209 
    52105210void code::print() 
    52115211{ 
    52125212    unsigned char ins; 
    52135213    code *c = this; 
    52145214 
    52155215    if (c == CNIL) 
    52165216    {   printf("code 0\n"); 
    52175217        return; 
    52185218    } 
    52195219 
    52205220    unsigned op = c->Iop; 
    52215221    if ((c->Iop & 0xFF00) == 0x0F00) 
    52225222        ins = inssize2[op & 0xFF]; 
    52235223    else 
    52245224        ins = inssize[op & 0xFF]; 
    52255225 
    52265226    printf("code %p: nxt=%p ",c,code_next(c)); 
    52275227    if (c->Irex) 
    5228         printf("rex=%x ", c->Irex); 
     5228    {   printf("rex=%x ", c->Irex); 
     5229        if (c->Irex & REX_W) 
     5230            printf("W"); 
     5231        if (c->Irex & REX_R) 
     5232            printf("R"); 
     5233        if (c->Irex & REX_X) 
     5234            printf("X"); 
     5235        if (c->Irex & REX_B) 
     5236            printf("B"); 
     5237        printf(" "); 
     5238    } 
    52295239    printf("op=%02x",op); 
    52305240 
    52315241  if ((op & 0xFF) == ESCAPE) 
    52325242  {     if ((op & 0xFF00) == ESClinnum) 
    52335243        {   printf(" linnum = %d\n",c->IEV2.Vsrcpos.Slinnum); 
    52345244            return; 
    52355245        } 
    52365246        printf(" ESCAPE %d",c->Iop >> 8); 
    52375247  } 
    52385248  if (c->Iflags) 
    52395249        printf(" flg=%x",c->Iflags); 
    52405250  if (ins & M) 
    52415251  {     unsigned rm = c->Irm; 
    52425252        printf(" rm=%02x=%d,%d,%d",rm,(rm>>6)&3,(rm>>3)&7,rm&7); 
    52435253        if (!I16 && issib(rm)) 
    52445254        {   unsigned char sib = c->Isib; 
    52455255            printf(" sib=%02x=%d,%d,%d",sib,(sib>>6)&3,(sib>>3)&7,sib&7); 
    52465256        } 
    52475257        if ((rm & 0xC7) == BPRM || (rm & 0xC0) == 0x80 || (rm & 0xC0) == 0x40) 
    52485258        { 

  • trunk/src/backend/cod4.c

    r768 r771  
    19741974        {       cl = getlvalue(&cs,e1,RMload); 
    19751975                freenode(e1); 
    19761976                if (evalinregister(e2)) 
    19771977                { 
    19781978                    retregs = idxregm(&cs); 
    19791979                    if ((cs.Iflags & CFSEG) == CFes) 
    19801980                            retregs |= mES;             /* take no chances */ 
    19811981                    rretregs = allregs & ~retregs; 
    19821982                    if (byte) 
    19831983                            rretregs &= BYTEREGS; 
    19841984                    cr = scodelem(e2,&rretregs,retregs,TRUE); 
    19851985                    cs.Iop = 0x39 ^ byte ^ reverse; 
    19861986                    if (sz > REGSIZE) 
    19871987                    { 
    19881988                        rreg = findregmsw(rretregs); 
    19891989                        cs.Irm |= modregrm(0,rreg,0); 
    19901990                        getlvalue_msw(&cs); 
    19911991                        c = gen(CNIL,&cs);              /* CMP EA+2,rreg */ 
    19921992                        if (I32 && sz == 6) 
    19931993                            c->Iflags |= CFopsize;      /* seg is only 16 bits  */ 
     1994                        if (I64 && byte && rreg >= 4) 
     1995                            c->Irex |= REX; 
    19941996                        genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop   */ 
    19951997                        rreg = findreglsw(rretregs); 
    19961998                        NEWREG(cs.Irm,rreg); 
    19971999                        getlvalue_lsw(&cs); 
    19982000                    } 
    19992001                    else 
    20002002                    { 
    20012003                        rreg = findreg(rretregs); 
    20022004                        code_newreg(&cs, rreg); 
     2005                        if (I64 && byte && rreg >= 4) 
     2006                            cs.Irex |= REX; 
    20032007                    } 
    20042008                } 
    20052009                else 
    20062010                { 
    20072011                    cs.Irm |= modregrm(0,7,0); 
    20082012                    if (sz > REGSIZE) 
    20092013                    { 
    20102014#if TARGET_FLAT 
    20112015                        if (sz == 6) 
    20122016                            assert(0); 
    20132017#endif 
    20142018                        if (e2->Eoper == OPrelconst) 
    20152019                        {   cs.Iflags = (cs.Iflags & ~(CFoff | CFseg)) | CFseg; 
    20162020                            cs.IEVoffset2 = 0; 
    20172021                        } 
    20182022                        getlvalue_msw(&cs); 
    20192023                        c = gen(CNIL,&cs);              /* CMP EA+2,const */ 
    20202024                        if (!I16 && sz == 6) 
    20212025                            c->Iflags |= CFopsize;      /* seg is only 16 bits  */ 
    20222026                        genjmp(c,JNE,FLcode,(block *) ce); /* JNE nop   */ 

  • trunk/src/backend/el.c

    r768 r771  
    29582958        case TYdouble: 
    29592959        case TYfloat: 
    29602960        case TYildouble: 
    29612961        case TYidouble: 
    29622962        case TYifloat: 
    29632963        case TYcldouble: 
    29642964        case TYcdouble: 
    29652965        case TYcfloat: 
    29662966#if !DDRT 
    29672967            result = (targ_llong)el_toldouble(e); 
    29682968#else 
    29692969            result = Xxtoi(el_toldouble(e)); 
    29702970#endif 
    29712971            break; 
    29722972 
    29732973#if SCPP 
    29742974        case TYmemptr: 
    29752975            ty = tybasic(tym_conv(e->ET)); 
    29762976            goto L1; 
    29772977#endif 
     2978 
     2979        case TYcent: 
     2980        case TYucent: 
     2981            goto Ullong; // should do better than this when actually doing arithmetic on cents 
     2982 
    29782983        default: 
    29792984#if SCPP 
    29802985            // Can happen as result of syntax errors 
    29812986            assert(errcnt); 
    29822987#else 
    29832988#ifdef DEBUG 
    29842989            elem_print(e); 
    29852990            *(char*)0=0; 
    29862991#endif 
    29872992            assert(0); 
    29882993#endif 
    29892994    } 
    29902995    return result; 
    29912996} 
    29922997 
    29932998/*********************************** 
    29942999 * Determine if constant e is all ones or all zeros. 
    29953000 * Input: 
    29963001 *      bit 0:  all zeros 
    29973002 *          1:  1 

  • trunk/src/iasm.c

    r714 r771  
    893893 
    894894STATIC opflag_t asm_determine_float_flags(OPND *popnd) 
    895895{ 
    896896    //printf("asm_determine_float_flags()\n"); 
    897897 
    898898    opflag_t us, usFloat; 
    899899 
    900900    // Insure that if it is a register, that it is not a normal processor 
    901901    // register. 
    902902 
    903903    if (popnd->base && 
    904904            !popnd->s && !popnd->disp && !popnd->real 
    905905            && !(popnd->base->ty & (_r8 | _r16 | _r32))) 
    906906    { 
    907907        return popnd->base->ty; 
    908908    } 
    909909    if (popnd->pregDisp1 && !popnd->base) 
    910910    { 
    911911        us = asm_float_type_size(popnd->ptype, &usFloat); 
    912912        //printf("us = x%x, usFloat = x%x\n", us, usFloat); 
    913         if (popnd->pregDisp1->ty & _r32) 
     913        if (popnd->pregDisp1->ty & (_r32 | _r64)) 
    914914            return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat)); 
    915915        else 
    916916        if (popnd->pregDisp1->ty & _r16) 
    917917            return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat)); 
    918918    } 
    919919    else if (popnd->s != 0) 
    920920    { 
    921921        us = asm_float_type_size(popnd->ptype, &usFloat); 
    922922        return CONSTRUCT_FLAGS(us, _m, _normal, usFloat); 
    923923    } 
    924924 
    925925    if (popnd->segreg) 
    926926    { 
    927927        us = asm_float_type_size(popnd->ptype, &usFloat); 
    928928        if (I16) 
    929929            return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat)); 
    930930        else 
    931931            return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat)); 
    932932    } 
    933933