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

Changeset 836

Show
Ignore:
Timestamp:
01/02/11 06:06:20 (14 years ago)
Author:
walter
Message:

64 bit arrayops tests now work

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r832 r836  
    15121512  retregs = *pretregs & possregs; 
    15131513  if (retregs == 0) 
    15141514        retregs = possregs; 
    15151515  c1 = codelem(e->E1,&retregs,FALSE); 
    15161516  cg = getregs(retregs);                /* retregs will be destroyed    */ 
    15171517#if 0 
    15181518  if (sz == 4 * REGSIZE) 
    15191519  { 
    15201520        c = gen2(CNIL,0xF7,modregrm(3,2,AX));   // NOT AX 
    15211521        gen2(c,0xF7,modregrm(3,2,BX));          // NOT BX 
    15221522        gen2(c,0xF7,modregrm(3,2,CX));          // NOT CX 
    15231523        gen2(c,0xF7,modregrm(3,2,DX));          // NOT DX 
    15241524  } 
    15251525  else 
    15261526#endif 
    15271527  { 
    15281528        reg = (sz <= REGSIZE) ? findreg(retregs) : findregmsw(retregs); 
    15291529        op = (sz == 1) ? 0xF6 : 0xF7; 
    15301530        c = genregs(CNIL,op,2,reg);             // NOT reg 
    15311531        code_orrex(c, rex); 
     1532        if (I64 && sz == 1 && reg >= 4) 
     1533            code_orrex(c, REX); 
    15321534        if (sz == 2 * REGSIZE) 
    15331535        {   reg = findreglsw(retregs); 
    15341536            genregs(c,op,2,reg);                // NOT reg+1 
    15351537        } 
    15361538  } 
    15371539  return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); 
    15381540} 
    15391541 
    15401542/************************ 
    15411543 * Bswap operator 
    15421544 */ 
    15431545 
    15441546code *cdbswap(elem *e,regm_t *pretregs) 
    15451547{   unsigned reg,op; 
    15461548    regm_t retregs; 
    15471549    code *c,*c1,*cg; 
    15481550    tym_t tym; 
    15491551    int sz; 
    15501552 
    15511553    if (*pretregs == 0) 
    …… 
    40384040            c1 = genc2(c1,0x81,modregrm(3,6,reg),0x80000000); /* XOR EDX,sign bit */ 
    40394041        } 
    40404042        else 
    40414043        {   reg = (sz == 8) ? AX : findregmsw(retregs); 
    40424044            c1 = genc2(c1,0x81,modregrm(3,6,reg),0x8000);     /* XOR AX,0x8000 */ 
    40434045        } 
    40444046        return cat(c1,fixresult(e,retregs,pretregs)); 
    40454047  } 
    40464048 
    40474049  byte = sz == 1; 
    40484050  possregs = (byte) ? BYTEREGS : allregs; 
    40494051  retregs = *pretregs & possregs; 
    40504052  if (retregs == 0) 
    40514053        retregs = possregs; 
    40524054  c1 = codelem(e->E1,&retregs,FALSE); 
    40534055  cg = getregs(retregs);                /* retregs will be destroyed    */ 
    40544056  if (sz <= REGSIZE) 
    40554057  { 
    40564058        unsigned reg = findreg(retregs); 
    40574059        unsigned rex = (I64 && sz == 8) ? REX_W : 0; 
     4060        if (I64 && sz == 1 && reg >= 4) 
     4061            rex |= REX; 
    40584062        c = gen2(CNIL,0xF7 ^ byte,(rex << 16) | modregrmx(3,3,reg));   // NEG reg 
    40594063        if (!I16 && tysize[tyml] == SHORTSIZE && *pretregs & mPSW) 
    40604064            c->Iflags |= CFopsize | CFpsw; 
    40614065        *pretregs &= mBP | ALLREGS;             // flags already set 
    40624066  } 
    40634067  else if (sz == 2 * REGSIZE) 
    40644068  {     unsigned msreg,lsreg; 
    40654069 
    40664070        msreg = findregmsw(retregs); 
    40674071        c = gen2(CNIL,0xF7,modregrm(3,3,msreg)); /* NEG msreg           */ 
    40684072        lsreg = findreglsw(retregs); 
    40694073        gen2(c,0xF7,modregrm(3,3,lsreg));       /* NEG lsreg            */ 
    40704074        genc2(c,0x81,modregrm(3,3,msreg),0);    /* SBB msreg,0          */ 
    40714075  } 
    40724076  else 
    40734077        assert(0); 
    40744078  return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); 
    40754079} 
    40764080 
    40774081 

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

    r834 r836  
    11771177  } 
    11781178  freenode(e1); 
    11791179  if (sz <= REGSIZE) 
    11801180        *pretregs &= ~mPSW;            // flags are already set 
    11811181  return cat(c,fixresult(e,retregs,pretregs)); 
    11821182} 
    11831183 
    11841184/******************************** 
    11851185 * Generate code for *= /= %= 
    11861186 */ 
    11871187 
    11881188code *cdmulass(elem *e,regm_t *pretregs) 
    11891189{ elem *e1,*e2; 
    11901190  code *cr,*cl,*cg,*c,cs; 
    11911191  tym_t tym,tyml; 
    11921192  regm_t retregs; 
    11931193  char uns; 
    11941194  unsigned op,resreg,reg,opr,lib,byte; 
    11951195  unsigned sz; 
    11961196 
     1197  //printf("cdmulass(e=%p, *pretregs = %s)\n",e,regm_str(*pretregs)); 
    11971198  e1 = e->E1; 
    11981199  e2 = e->E2; 
    11991200  op = e->Eoper;                        /* OPxxxx                       */ 
    12001201 
    12011202  tyml = tybasic(e1->Ety);              /* type of lvalue               */ 
    12021203  uns = tyuns(tyml) || tyuns(e2->Ety); 
    12031204  tym = tybasic(e->Ety);                /* type of result               */ 
    12041205  sz = tysize[tyml]; 
    12051206 
    12061207    unsigned rex = (I64 && sz == 8) ? REX_W : 0; 
    12071208    unsigned grex = rex << 16;          // 64 bit operands 
    12081209 
    12091210 
    12101211  if (tyfloating(tyml)) 
    12111212#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS 
    12121213        return opass87(e,pretregs); 
    12131214#else 
    12141215        return opassdbl(e,pretregs,op); 
    12151216#endif 
    12161217 
    …… 
    12511252            { 
    12521253             L1: 
    12531254                retregs = *pretregs & (ALLREGS | mBP); 
    12541255                if (!retregs) 
    12551256                    retregs = ALLREGS; 
    12561257                cr = codelem(e2,&retregs,FALSE); /* load rvalue in reg  */ 
    12571258                cl = getlvalue(&cs,e1,retregs); /* get EA               */ 
    12581259                cg = getregs(retregs);          /* destroy these regs   */ 
    12591260                cs.Iop = 0x0FAF;                // IMUL resreg,EA 
    12601261                resreg = findreg(retregs); 
    12611262                opr = resreg; 
    12621263            } 
    12631264            else 
    12641265            { 
    12651266                retregs = mAX; 
    12661267                cr = codelem(e2,&retregs,FALSE); // load rvalue in AX 
    12671268                cl = getlvalue(&cs,e1,mAX);     // get EA 
    12681269                cg = getregs(byte ? mAX : mAX | mDX); // destroy these regs 
    12691270                cs.Iop = 0xF7 ^ byte;           // [I]MUL EA 
    12701271            } 
    1271             cs.Irm |= modregrm(0,opr,0); 
     1272            code_newreg(&cs,opr); 
    12721273            c = gen(CNIL,&cs); 
    12731274        } 
    12741275        else // /= or %= 
    12751276        {   targ_size_t e2factor; 
    12761277            int pow2; 
    12771278            targ_ulong m; 
    12781279 
    12791280            assert(!byte);                      // should never happen 
    12801281            assert(I16 || sz != SHORTSIZE); 
    12811282            if (config.flags4 & CFG4speed && 
    12821283                e2->Eoper == OPconst && !uns && 
    12831284                (sz == REGSIZE || (I64 && sz == 4)) && 
    12841285                (pow2 = ispow2(e2factor = el_tolong(e2))) != -1 && 
    12851286                e2factor == (int)e2factor && 
    12861287                !(config.target_cpu < TARGET_80286 && pow2 != 1 && op == OPdivass) 
    12871288               ) 
    12881289            { 
    12891290                // Signed divide or modulo by power of 2 
    12901291                cr = NULL; 
    12911292                c = NULL; 
    …… 
    13381339                retregs = ALLREGS & ~(mAX|mDX);         // DX gets sign extension 
    13391340                cr = codelem(e2,&retregs,FALSE);        // load rvalue in retregs 
    13401341                reg = findreg(retregs); 
    13411342                cl = getlvalue(&cs,e1,mAX | mDX | retregs);     // get EA 
    13421343                cg = getregs(mAX | mDX);        // destroy these regs 
    13431344                cs.Irm |= modregrm(0,AX,0); 
    13441345                cs.Iop = 0x8B; 
    13451346                c = gen(CNIL,&cs);              // MOV AX,EA 
    13461347                if (uns)                        // if unsigned 
    13471348                    movregconst(c,DX,0,0);      // CLR DX 
    13481349                else                            // else signed 
    13491350                {   gen1(c,0x99);               // CWD 
    13501351                    code_orrex(c,rex); 
    13511352                } 
    13521353                c = cat(c,getregs(mDX | mAX));  // DX and AX will be destroyed 
    13531354                genregs(c,0xF7,opr,reg);        // OPR reg 
    13541355                code_orrex(c,rex); 
    13551356            } 
    13561357        } 
    13571358        cs.Iop = 0x89 ^ byte; 
    1358         NEWREG(cs.Irm,resreg); 
     1359        code_newreg(&cs,resreg); 
    13591360        c = gen(c,&cs);                         // MOV EA,resreg 
    13601361        if (e1->Ecount)                         // if we gen a CSE 
    13611362                cssave(e1,mask[resreg],EOP(e1)); 
    13621363        freenode(e1); 
    13631364        c = cat(c,fixresult(e,mask[resreg],pretregs)); 
    13641365        return cat4(cr,cl,cg,c); 
    13651366  } 
    13661367  else if (sz == 2 * REGSIZE) 
    13671368  { 
    13681369        lib = CLIBlmul; 
    13691370        if (op == OPdivass || op == OPmodass) 
    13701371        {       lib = (uns) ? CLIBuldiv : CLIBldiv; 
    13711372                if (op == OPmodass) 
    13721373                        lib++; 
    13731374        } 
    13741375        retregs = mCX | mBX; 
    13751376        cr = codelem(e2,&retregs,FALSE); 
    13761377        cl = getlvalue(&cs,e1,mDX|mAX | mCX|mBX); 
    13771378        cl = cat(cl,getregs(mDX | mAX)); 
    13781379        cs.Iop = 0x8B; 
    …… 
    28242825     L1: 
    28252826        if (!I16) 
    28262827        { 
    28272828            if (op == OPs8int && reg == AX && size == 2) 
    28282829            {   c3 = gen1(c3,0x98);             /* CBW                  */ 
    28292830                c3->Iflags |= CFopsize;         /* don't do a CWDE      */ 
    28302831            } 
    28312832            else 
    28322833            { 
    28332834                /* We could do better by not forcing the src and dst    */ 
    28342835                /* registers to be the same.                            */ 
    28352836 
    28362837                if (config.flags4 & CFG4speed && op == OPu8_16) 
    28372838                {   // AND reg,0xFF 
    28382839                    c3 = genc2(c3,0x81,modregrmx(3,4,reg),0xFF); 
    28392840                } 
    28402841                else 
    28412842                { 
    28422843                    unsigned iop = (op == OPu8int) ? 0x0FB6 : 0x0FBE; // MOVZX/MOVSX reg,reg 
    28432844                    c3 = genregs(c3,iop,reg,reg); 
     2845                    if (I64 && reg >= 4) 
     2846                        code_orrex(c3, REX); 
    28442847                } 
    28452848            } 
    28462849        } 
    28472850        else 
    28482851        { 
    28492852            if (op == OPu8int) 
    28502853                c3 = genregs(c3,0x30,reg+4,reg+4);      // XOR regH,regH 
    28512854            else 
    28522855            { 
    28532856                c3 = gen1(c3,0x98);             /* CBW                  */ 
    28542857                *pretregs &= ~mPSW;             /* flags already set    */ 
    28552858            } 
    28562859        } 
    28572860    } 
    28582861    c2 = getregs(retregs); 
    28592862L2: 
    28602863    c4 = fixresult(e,retregs,pretregs); 
    28612864    return cat6(c0,c1,c2,c3,c4,NULL); 
    28622865} 
    28632866 

  • trunk/src/backend/cod2.c

    r832 r836  
    15121512  retregs = *pretregs & possregs; 
    15131513  if (retregs == 0) 
    15141514        retregs = possregs; 
    15151515  c1 = codelem(e->E1,&retregs,FALSE); 
    15161516  cg = getregs(retregs);                /* retregs will be destroyed    */ 
    15171517#if 0 
    15181518  if (sz == 4 * REGSIZE) 
    15191519  { 
    15201520        c = gen2(CNIL,0xF7,modregrm(3,2,AX));   // NOT AX 
    15211521        gen2(c,0xF7,modregrm(3,2,BX));          // NOT BX 
    15221522        gen2(c,0xF7,modregrm(3,2,CX));          // NOT CX 
    15231523        gen2(c,0xF7,modregrm(3,2,DX));          // NOT DX 
    15241524  } 
    15251525  else 
    15261526#endif 
    15271527  { 
    15281528        reg = (sz <= REGSIZE) ? findreg(retregs) : findregmsw(retregs); 
    15291529        op = (sz == 1) ? 0xF6 : 0xF7; 
    15301530        c = genregs(CNIL,op,2,reg);             // NOT reg 
    15311531        code_orrex(c, rex); 
     1532        if (I64 && sz == 1 && reg >= 4) 
     1533            code_orrex(c, REX); 
    15321534        if (sz == 2 * REGSIZE) 
    15331535        {   reg = findreglsw(retregs); 
    15341536            genregs(c,op,2,reg);                // NOT reg+1 
    15351537        } 
    15361538  } 
    15371539  return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); 
    15381540} 
    15391541 
    15401542/************************ 
    15411543 * Bswap operator 
    15421544 */ 
    15431545 
    15441546code *cdbswap(elem *e,regm_t *pretregs) 
    15451547{   unsigned reg,op; 
    15461548    regm_t retregs; 
    15471549    code *c,*c1,*cg; 
    15481550    tym_t tym; 
    15491551    int sz; 
    15501552 
    15511553    if (*pretregs == 0) 
    …… 
    40384040            c1 = genc2(c1,0x81,modregrm(3,6,reg),0x80000000); /* XOR EDX,sign bit */ 
    40394041        } 
    40404042        else 
    40414043        {   reg = (sz == 8) ? AX : findregmsw(retregs); 
    40424044            c1 = genc2(c1,0x81,modregrm(3,6,reg),0x8000);     /* XOR AX,0x8000 */ 
    40434045        } 
    40444046        return cat(c1,fixresult(e,retregs,pretregs)); 
    40454047  } 
    40464048 
    40474049  byte = sz == 1; 
    40484050  possregs = (byte) ? BYTEREGS : allregs; 
    40494051  retregs = *pretregs & possregs; 
    40504052  if (retregs == 0) 
    40514053        retregs = possregs; 
    40524054  c1 = codelem(e->E1,&retregs,FALSE); 
    40534055  cg = getregs(retregs);                /* retregs will be destroyed    */ 
    40544056  if (sz <= REGSIZE) 
    40554057  { 
    40564058        unsigned reg = findreg(retregs); 
    40574059        unsigned rex = (I64 && sz == 8) ? REX_W : 0; 
     4060        if (I64 && sz == 1 && reg >= 4) 
     4061            rex |= REX; 
    40584062        c = gen2(CNIL,0xF7 ^ byte,(rex << 16) | modregrmx(3,3,reg));   // NEG reg 
    40594063        if (!I16 && tysize[tyml] == SHORTSIZE && *pretregs & mPSW) 
    40604064            c->Iflags |= CFopsize | CFpsw; 
    40614065        *pretregs &= mBP | ALLREGS;             // flags already set 
    40624066  } 
    40634067  else if (sz == 2 * REGSIZE) 
    40644068  {     unsigned msreg,lsreg; 
    40654069 
    40664070        msreg = findregmsw(retregs); 
    40674071        c = gen2(CNIL,0xF7,modregrm(3,3,msreg)); /* NEG msreg           */ 
    40684072        lsreg = findreglsw(retregs); 
    40694073        gen2(c,0xF7,modregrm(3,3,lsreg));       /* NEG lsreg            */ 
    40704074        genc2(c,0x81,modregrm(3,3,msreg),0);    /* SBB msreg,0          */ 
    40714075  } 
    40724076  else 
    40734077        assert(0); 
    40744078  return cat4(c1,cg,c,fixresult(e,retregs,pretregs)); 
    40754079} 
    40764080 
    40774081 

  • trunk/src/backend/cod4.c

    r834 r836  
    11771177  } 
    11781178  freenode(e1); 
    11791179  if (sz <= REGSIZE) 
    11801180        *pretregs &= ~mPSW;            // flags are already set 
    11811181  return cat(c,fixresult(e,retregs,pretregs)); 
    11821182} 
    11831183 
    11841184/******************************** 
    11851185 * Generate code for *= /= %= 
    11861186 */ 
    11871187 
    11881188code *cdmulass(elem *e,regm_t *pretregs) 
    11891189{ elem *e1,*e2; 
    11901190  code *cr,*cl,*cg,*c,cs; 
    11911191  tym_t tym,tyml; 
    11921192  regm_t retregs; 
    11931193  char uns; 
    11941194  unsigned op,resreg,reg,opr,lib,byte; 
    11951195  unsigned sz; 
    11961196 
     1197  //printf("cdmulass(e=%p, *pretregs = %s)\n",e,regm_str(*pretregs)); 
    11971198  e1 = e->E1; 
    11981199  e2 = e->E2; 
    11991200  op = e->Eoper;                        /* OPxxxx                       */ 
    12001201 
    12011202  tyml = tybasic(e1->Ety);              /* type of lvalue               */ 
    12021203  uns = tyuns(tyml) || tyuns(e2->Ety); 
    12031204  tym = tybasic(e->Ety);                /* type of result               */ 
    12041205  sz = tysize[tyml]; 
    12051206 
    12061207    unsigned rex = (I64 && sz == 8) ? REX_W : 0; 
    12071208    unsigned grex = rex << 16;          // 64 bit operands 
    12081209 
    12091210 
    12101211  if (tyfloating(tyml)) 
    12111212#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS 
    12121213        return opass87(e,pretregs); 
    12131214#else 
    12141215        return opassdbl(e,pretregs,op); 
    12151216#endif 
    12161217 
    …… 
    12511252            { 
    12521253             L1: 
    12531254                retregs = *pretregs & (ALLREGS | mBP); 
    12541255                if (!retregs) 
    12551256                    retregs = ALLREGS; 
    12561257                cr = codelem(e2,&retregs,FALSE); /* load rvalue in reg  */ 
    12571258                cl = getlvalue(&cs,e1,retregs); /* get EA               */ 
    12581259                cg = getregs(retregs);          /* destroy these regs   */ 
    12591260                cs.Iop = 0x0FAF;                // IMUL resreg,EA 
    12601261                resreg = findreg(retregs); 
    12611262                opr = resreg; 
    12621263            } 
    12631264            else 
    12641265            { 
    12651266                retregs = mAX; 
    12661267                cr = codelem(e2,&retregs,FALSE); // load rvalue in AX 
    12671268                cl = getlvalue(&cs,e1,mAX);     // get EA 
    12681269                cg = getregs(byte ? mAX : mAX | mDX); // destroy these regs 
    12691270                cs.Iop = 0xF7 ^ byte;           // [I]MUL EA 
    12701271            } 
    1271             cs.Irm |= modregrm(0,opr,0); 
     1272            code_newreg(&cs,opr); 
    12721273            c = gen(CNIL,&cs); 
    12731274        } 
    12741275        else // /= or %= 
    12751276        {   targ_size_t e2factor; 
    12761277            int pow2; 
    12771278            targ_ulong m; 
    12781279 
    12791280            assert(!byte);                      // should never happen 
    12801281            assert(I16 || sz != SHORTSIZE); 
    12811282            if (config.flags4 & CFG4speed && 
    12821283                e2->Eoper == OPconst && !uns && 
    12831284                (sz == REGSIZE || (I64 && sz == 4)) && 
    12841285                (pow2 = ispow2(e2factor = el_tolong(e2))) != -1 && 
    12851286                e2factor == (int)e2factor && 
    12861287                !(config.target_cpu < TARGET_80286 && pow2 != 1 && op == OPdivass) 
    12871288               ) 
    12881289            { 
    12891290                // Signed divide or modulo by power of 2 
    12901291                cr = NULL; 
    12911292                c = NULL; 
    …… 
    13381339                retregs = ALLREGS & ~(mAX|mDX);         // DX gets sign extension 
    13391340                cr = codelem(e2,&retregs,FALSE);        // load rvalue in retregs 
    13401341                reg = findreg(retregs); 
    13411342                cl = getlvalue(&cs,e1,mAX | mDX | retregs);     // get EA 
    13421343                cg = getregs(mAX | mDX);        // destroy these regs 
    13431344                cs.Irm |= modregrm(0,AX,0); 
    13441345                cs.Iop = 0x8B; 
    13451346                c = gen(CNIL,&cs);              // MOV AX,EA 
    13461347                if (uns)                        // if unsigned 
    13471348                    movregconst(c,DX,0,0);      // CLR DX 
    13481349                else                            // else signed 
    13491350                {   gen1(c,0x99);               // CWD 
    13501351                    code_orrex(c,rex); 
    13511352                } 
    13521353                c = cat(c,getregs(mDX | mAX));  // DX and AX will be destroyed 
    13531354                genregs(c,0xF7,opr,reg);        // OPR reg 
    13541355                code_orrex(c,rex); 
    13551356            } 
    13561357        } 
    13571358        cs.Iop = 0x89 ^ byte; 
    1358         NEWREG(cs.Irm,resreg); 
     1359        code_newreg(&cs,resreg); 
    13591360        c = gen(c,&cs);                         // MOV EA,resreg 
    13601361        if (e1->Ecount)                         // if we gen a CSE 
    13611362                cssave(e1,mask[resreg],EOP(e1)); 
    13621363        freenode(e1); 
    13631364        c = cat(c,fixresult(e,mask[resreg],pretregs)); 
    13641365        return cat4(cr,cl,cg,c); 
    13651366  } 
    13661367  else if (sz == 2 * REGSIZE) 
    13671368  { 
    13681369        lib = CLIBlmul; 
    13691370        if (op == OPdivass || op == OPmodass) 
    13701371        {       lib = (uns) ? CLIBuldiv : CLIBldiv; 
    13711372                if (op == OPmodass) 
    13721373                        lib++; 
    13731374        } 
    13741375        retregs = mCX | mBX; 
    13751376        cr = codelem(e2,&retregs,FALSE); 
    13761377        cl = getlvalue(&cs,e1,mDX|mAX | mCX|mBX); 
    13771378        cl = cat(cl,getregs(mDX | mAX)); 
    13781379        cs.Iop = 0x8B; 
    …… 
    28242825     L1: 
    28252826        if (!I16) 
    28262827        { 
    28272828            if (op == OPs8int && reg == AX && size == 2) 
    28282829            {   c3 = gen1(c3,0x98);             /* CBW                  */ 
    28292830                c3->Iflags |= CFopsize;         /* don't do a CWDE      */ 
    28302831            } 
    28312832            else 
    28322833            { 
    28332834                /* We could do better by not forcing the src and dst    */ 
    28342835                /* registers to be the same.                            */ 
    28352836 
    28362837                if (config.flags4 & CFG4speed && op == OPu8_16) 
    28372838                {   // AND reg,0xFF 
    28382839                    c3 = genc2(c3,0x81,modregrmx(3,4,reg),0xFF); 
    28392840                } 
    28402841                else 
    28412842                { 
    28422843                    unsigned iop = (op == OPu8int) ? 0x0FB6 : 0x0FBE; // MOVZX/MOVSX reg,reg 
    28432844                    c3 = genregs(c3,iop,reg,reg); 
     2845                    if (I64 && reg >= 4) 
     2846                        code_orrex(c3, REX); 
    28442847                } 
    28452848            } 
    28462849        } 
    28472850        else 
    28482851        { 
    28492852            if (op == OPu8int) 
    28502853                c3 = genregs(c3,0x30,reg+4,reg+4);      // XOR regH,regH 
    28512854            else 
    28522855            { 
    28532856                c3 = gen1(c3,0x98);             /* CBW                  */ 
    28542857                *pretregs &= ~mPSW;             /* flags already set    */ 
    28552858            } 
    28562859        } 
    28572860    } 
    28582861    c2 = getregs(retregs); 
    28592862L2: 
    28602863    c4 = fixresult(e,retregs,pretregs); 
    28612864    return cat6(c0,c1,c2,c3,c4,NULL); 
    28622865} 
    28632866