From 3658e62895dfe4da844bb97b8b73a79df6e509b5 Mon Sep 17 00:00:00 2001 From: Walter Bright Date: Wed, 19 Jun 2024 22:44:47 -0700 Subject: [PATCH] modernize parameters to loadea() --- compiler/src/dmd/backend/x86/cg87.d | 20 +++---- compiler/src/dmd/backend/x86/cgxmm.d | 4 +- compiler/src/dmd/backend/x86/cod1.d | 85 ++++++++++++++-------------- compiler/src/dmd/backend/x86/cod2.d | 20 +++---- compiler/src/dmd/backend/x86/cod4.d | 26 ++++----- 5 files changed, 77 insertions(+), 78 deletions(-) diff --git a/compiler/src/dmd/backend/x86/cg87.d b/compiler/src/dmd/backend/x86/cg87.d index 12e4a5ba02b2..bf53f90ca93e 100644 --- a/compiler/src/dmd/backend/x86/cg87.d +++ b/compiler/src/dmd/backend/x86/cg87.d @@ -1691,12 +1691,12 @@ L5: case TYcfloat: case TYcdouble: case TYdouble_alias: - loadea(cdb,e,&cs,ESC(mf,1),0,0,0,0); // FLD var + loadea(cdb,e,cs,ESC(mf,1),0,0,0,0); // FLD var break; case TYldouble: case TYildouble: case TYcldouble: - loadea(cdb,e,&cs,0xDB,5,0,0,0); // FLD var + loadea(cdb,e,cs,0xDB,5,0,0,0); // FLD var break; default: printf("ty = x%x\n", ty); @@ -1734,7 +1734,7 @@ L5: } else { - loadea(cdb,e.E1,&cs,ESC(mf1,1),0,0,0,0); /* FLD e.E1 */ + loadea(cdb,e.E1,cs,ESC(mf1,1),0,0,0,0); /* FLD e.E1 */ } // Variable cannot be put into a register anymore @@ -2011,7 +2011,7 @@ void eq87(ref CodeBuilder cdb,elem *e,regm_t *pretregs) static if (0) { // Doesn't work if ST(0) gets saved to the stack by getlvalue() - loadea(cdb,e.E1,&cs,op1,op2,0,0,0); + loadea(cdb,e.E1,cs,op1,op2,0,0,0); } else { @@ -2084,7 +2084,7 @@ void complex_eq87(ref CodeBuilder cdb,elem *e,regm_t *pretregs) { code cs; opcode_t op1; - uint op2; + ubyte op2; uint sz; int fxch = 0; @@ -2140,7 +2140,7 @@ void complex_eq87(ref CodeBuilder cdb,elem *e,regm_t *pretregs) } else { - loadea(cdb,e.E1,&cs,op1,op2,sz,0,0); + loadea(cdb,e.E1,cs,op1,op2,sz,0,0); genfwait(cdb); } if (fxch) @@ -2204,7 +2204,7 @@ private void cnvteq87(ref CodeBuilder cdb,elem *e,regm_t *pretregs) { code cs; opcode_t op1; - uint op2; + ubyte op2; assert(e.Eoper == OPeq); assert(!*pretregs); @@ -2238,7 +2238,7 @@ private void cnvteq87(ref CodeBuilder cdb,elem *e,regm_t *pretregs) cs.Iflags = ADDFWAIT() ? CFwait : 0; if (e.E1.Eoper == OPvar) notreg(e.E1); // cannot be put in register anymore - loadea(cdb,e.E1,&cs,op1,op2,0,0,0); + loadea(cdb,e.E1,cs,op1,op2,0,0,0); genfwait(cdb); genSetRoundingMode(cdb, CW.roundtonearest); // FLDCW roundtonearest @@ -3839,13 +3839,13 @@ void cload87(ref CodeBuilder cdb, elem *e, ref regm_t outretregs) { case TYcfloat: case TYcdouble: - loadea(cdb,e,&cs,ESC(mf,1),0,0,0,0); // FLD var + loadea(cdb,e,cs,ESC(mf,1),0,0,0,0); // FLD var cs.IEV1.Voffset += sz; cdb.gen(&cs); break; case TYcldouble: - loadea(cdb,e,&cs,0xDB,5,0,0,0); // FLD var + loadea(cdb,e,cs,0xDB,5,0,0,0); // FLD var cs.IEV1.Voffset += sz; cdb.gen(&cs); break; diff --git a/compiler/src/dmd/backend/x86/cgxmm.d b/compiler/src/dmd/backend/x86/cgxmm.d index c6005eb14297..3272e6e60c15 100644 --- a/compiler/src/dmd/backend/x86/cgxmm.d +++ b/compiler/src/dmd/backend/x86/cgxmm.d @@ -1931,12 +1931,12 @@ void cloadxmm(ref CodeBuilder cdb, elem *e, regm_t *pretregs) regm_t retregs0 = mXMM0; reg_t reg0 = allocreg(cdb, retregs0, ty); - loadea(cdb, e, &cs, opmv, reg0, 0, RMload, 0); // MOVSS/MOVSD XMM0,data + loadea(cdb, e, cs, opmv, reg0, 0, RMload, 0); // MOVSS/MOVSD XMM0,data checkSetVex(cdb.last(), ty); regm_t retregs1 = mXMM1; reg_t reg1 = allocreg(cdb, retregs1, ty); - loadea(cdb, e, &cs, opmv, reg1, tysize(ty), RMload, mXMM0); // MOVSS/MOVSD XMM1,data+offset + loadea(cdb, e, cs, opmv, reg1, tysize(ty), RMload, mXMM0); // MOVSS/MOVSD XMM1,data+offset checkSetVex(cdb.last(), ty); return; diff --git a/compiler/src/dmd/backend/x86/cod1.d b/compiler/src/dmd/backend/x86/cod1.d index 7b626c0da08b..9525e13d660a 100644 --- a/compiler/src/dmd/backend/x86/cod1.d +++ b/compiler/src/dmd/backend/x86/cod1.d @@ -600,20 +600,19 @@ void logexp(ref CodeBuilder cdb, elem *e, int jcond, uint fltarg, code *targ) * Routine to aid in setting things up for gen(). * Look for common subexpression. * Can handle indirection operators, but not if they're common subs. - * Input: - * e -> elem where we get some of the data from - * cs -> partially filled code to add - * op = opcode - * reg = reg field of (mod reg r/m) - * offset = data to be added to Voffset field + * Params: + * cdb = generated code sink + * e = elem where we get some of the data from + * cs = partially filled code to add + * op = opcode + * reg = reg field of (mod reg r/m) + * offset = data to be added to Voffset field * keepmsk = mask of registers we must not destroy * desmsk = mask of registers destroyed by executing the instruction - * Returns: - * pointer to code generated */ @trusted -void loadea(ref CodeBuilder cdb,elem *e,code *cs,uint op,uint reg,targ_size_t offset, +void loadea(ref CodeBuilder cdb,elem *e,ref code cs,uint op,reg_t reg,targ_size_t offset, regm_t keepmsk,regm_t desmsk) { code* c, cg, cd; @@ -621,7 +620,7 @@ void loadea(ref CodeBuilder cdb,elem *e,code *cs,uint op,uint reg,targ_size_t of debug if (debugw) printf("loadea: e=%p cs=%p op=x%x reg=%s offset=%lld keepmsk=%s desmsk=%s\n", - e, cs, op, regstring[reg], cast(ulong)offset, regm_str(keepmsk), regm_str(desmsk)); + e, &cs, op, regstring[reg], cast(ulong)offset, regm_str(keepmsk), regm_str(desmsk)); assert(e); cs.Iflags = 0; cs.Irex = 0; @@ -671,7 +670,7 @@ void loadea(ref CodeBuilder cdb,elem *e,code *cs,uint op,uint reg,targ_size_t of cs.Iop = 0x8C; /* MOV reg,ES */ cs.Irm = modregrm(3, 0, reg & 7); if (reg & 8) - code_orrex(cs, REX_B); + code_orrex(&cs, REX_B); } else // XXX reg,i { @@ -692,9 +691,9 @@ void loadea(ref CodeBuilder cdb,elem *e,code *cs,uint op,uint reg,targ_size_t of } } - getlvalue(cdb, *cs, e, keepmsk); + getlvalue(cdb, cs, e, keepmsk); if (offset == REGSIZE) - getlvalue_msw(*cs); + getlvalue_msw(cs); else cs.IEV1.Voffset += offset; if (I64) @@ -708,7 +707,7 @@ void loadea(ref CodeBuilder cdb,elem *e,code *cs,uint op,uint reg,targ_size_t of (op == LODSD || op == STOSD)) cs.Irex &= ~REX_W; // not needed for xmm ops } - code_newreg(cs, reg); // OR in reg field + code_newreg(&cs, reg); // OR in reg field if (!I16) { if (reg == 6 && op == 0xFF || /* don't PUSH a word */ @@ -761,7 +760,7 @@ L2: cs.Iop = NOP; } - cdb.gen(cs); + cdb.gen(&cs); } @@ -3973,7 +3972,7 @@ private void funccall(ref CodeBuilder cdb, elem* e, uint numpara, uint numalign, // CALL [function] cs.Iflags = 0; cgstate.stackclean++; - loadea(cdbe, e11, &cs, 0xFF, farfunc ? 3 : 2, 0, keepmsk, desmsk); + loadea(cdbe, e11, cs, 0xFF, farfunc ? 3 : 2, 0, keepmsk, desmsk); cgstate.stackclean--; freenode(e11); } @@ -4651,7 +4650,7 @@ void pushParams(ref CodeBuilder cdb, elem* e, uint stackalign, tym_t tyf) if (I32) { assert(sz >= REGSIZE * 2); - loadea(cdb, e, &cs, 0xFF, 6, sz - REGSIZE, 0, 0); // PUSH EA+4 + loadea(cdb, e, cs, 0xFF, 6, sz - REGSIZE, 0, 0); // PUSH EA+4 cdb.genadjesp(REGSIZE); cgstate.stackpush += REGSIZE; sz -= REGSIZE; @@ -4674,7 +4673,7 @@ void pushParams(ref CodeBuilder cdb, elem* e, uint stackalign, tym_t tyf) { if (sz == DOUBLESIZE) { - loadea(cdb, e, &cs, 0xFF, 6, DOUBLESIZE - REGSIZE, 0, 0); // PUSH EA+6 + loadea(cdb, e, cs, 0xFF, 6, DOUBLESIZE - REGSIZE, 0, 0); // PUSH EA+6 cs.IEV1.Voffset -= REGSIZE; cdb.gen(&cs); // PUSH EA+4 cdb.genadjesp(REGSIZE); @@ -4682,7 +4681,7 @@ void pushParams(ref CodeBuilder cdb, elem* e, uint stackalign, tym_t tyf) cdb.gen(&cs); // PUSH EA+2 } else /* TYlong */ - loadea(cdb, e, &cs, 0xFF, 6, REGSIZE, 0, 0); // PUSH EA+2 + loadea(cdb, e, cs, 0xFF, 6, REGSIZE, 0, 0); // PUSH EA+2 cdb.genadjesp(REGSIZE); } cgstate.stackpush += sz; @@ -4802,13 +4801,13 @@ void pushParams(ref CodeBuilder cdb, elem* e, uint stackalign, tym_t tyf) code cs; cs.Iflags = 0; cs.Irex = 0; - loadea(cdb, e, &cs, 0xFF, 6, sz - regsize, RMload, 0); // PUSH EA+sz-2 + loadea(cdb, e, cs, 0xFF, 6, sz - regsize, RMload, 0); // PUSH EA+sz-2 code_orflag(cdb.last(), flag); cdb.genadjesp(REGSIZE); cgstate.stackpush += sz; while (cast(targ_int)(sz -= regsize) > 0) { - loadea(cdb, e, &cs, 0xFF, 6, sz - regsize, RMload, 0); + loadea(cdb, e, cs, 0xFF, 6, sz - regsize, RMload, 0); code_orflag(cdb.last(), flag); cdb.genadjesp(REGSIZE); } @@ -5214,13 +5213,13 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) if (!I16 && (tym == TYfloat || tym == TYifloat)) { reg = allocreg(cdb, regm, TYoffset); // get a register - loadea(cdb, e, &cs, 0x8B, reg, 0, 0, 0); // MOV reg,data + loadea(cdb, e, cs, 0x8B, reg, 0, 0, 0); // MOV reg,data cdb.gen2(0xD1,modregrmx(3,4,reg)); // SHL reg,1 } else if (I64 && (tym == TYdouble || tym ==TYidouble)) { reg = allocreg(cdb, regm, TYoffset); // get a register - loadea(cdb, e,&cs, 0x8B, reg, 0, 0, 0); // MOV reg,data + loadea(cdb, e, cs, 0x8B, reg, 0, 0, 0); // MOV reg,data // remove sign bit, so that -0.0 == 0.0 cdb.gen2(0xD1, modregrmx(3, 4, reg)); // SHL reg,1 code_orrex(cdb.last(), REX_W); @@ -5228,14 +5227,14 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) else if (TARGET_OSX && e.Eoper == OPvar && movOnly(e)) { reg = allocreg(cdb, regm, TYoffset); // get a register - loadea(cdb, e, &cs, 0x8B, reg, 0, 0, 0); // MOV reg,data + loadea(cdb, e, cs, 0x8B, reg, 0, 0, 0); // MOV reg,data fixresult(cdb, e, regm, outretregs); } else { cs.IFL2 = FLconst; cs.IEV2.Vsize_t = 0; op = (sz == 1) ? 0x80 : 0x81; - loadea(cdb, e, &cs, op, 7, 0, 0, 0); // CMP EA,0 + loadea(cdb, e, cs, op, 7, 0, 0, 0); // CMP EA,0 // Convert to TEST instruction if EA is a register // (to avoid register contention on Pentium) @@ -5256,26 +5255,26 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) { reg = allocreg(cdb, regm, TYoffset); // get a register if (I32) // it's a 48 bit pointer - loadea(cdb, e, &cs, MOVZXw, reg, REGSIZE, 0, 0); // MOVZX reg,data+4 + loadea(cdb, e, cs, MOVZXw, reg, REGSIZE, 0, 0); // MOVZX reg,data+4 else { - loadea(cdb, e, &cs, 0x8B, reg, REGSIZE, 0, 0); // MOV reg,data+2 + loadea(cdb, e, cs, 0x8B, reg, REGSIZE, 0, 0); // MOV reg,data+2 if (tym == TYfloat || tym == TYifloat) // dump sign bit cdb.gen2(0xD1, modregrm(3, 4, reg)); // SHL reg,1 } - loadea(cdb,e,&cs,0x0B,reg,0,regm,0); // OR reg,data + loadea(cdb,e,cs,0x0B,reg,0,regm,0); // OR reg,data } else if (sz == 8 || (I64 && sz == 2 * REGSIZE && !tyfloating(tym))) { reg = allocreg(cdb, regm, TYoffset); // get a register int i = sz - REGSIZE; - loadea(cdb, e, &cs, 0x8B, reg, i, 0, 0); // MOV reg,data+6 + loadea(cdb, e, cs, 0x8B, reg, i, 0, 0); // MOV reg,data+6 if (tyfloating(tym)) // TYdouble or TYdouble_alias cdb.gen2(0xD1, modregrm(3, 4, reg)); // SHL reg,1 while ((i -= REGSIZE) >= 0) { - loadea(cdb, e, &cs, 0x0B, reg, i, regm, 0); // OR reg,data+i + loadea(cdb, e, cs, 0x0B, reg, i, regm, 0); // OR reg,data+i code *c = cdb.last(); if (i == 0) c.Iflags |= CFpsw; // need the flags on last OR @@ -5467,7 +5466,7 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) { // opmv = tyuns(tym) ? MOVZXb : MOVSXb; // MOVZX/MOVSX } - loadea(cdb, e, &cs, opmv, reg, 0, 0, 0); // MOV regL,data + loadea(cdb, e, cs, opmv, reg, 0, 0, 0); // MOV regL,data } else { @@ -5476,7 +5475,7 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) nreg = reg; // already allocated else nreg = allocreg(cdb, nregm, tym); - loadea(cdb, e, &cs, opmv, nreg, 0, 0, 0); // MOV nregL,data + loadea(cdb, e, cs, opmv, nreg, 0, 0, 0); // MOV nregL,data if (reg != nreg) { genmovreg(cdb, reg, nreg); // MOV reg,nreg @@ -5498,7 +5497,7 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) /* getlvalue() will unwind this and unregister s; could use a better solution */ } } - loadea(cdb, e, &cs, opmv, reg, 0, RMload, 0); // MOVSS/MOVSD reg,data + loadea(cdb, e, cs, opmv, reg, 0, RMload, 0); // MOVSS/MOVSD reg,data checkSetVex(cdb.last(),tym); } else if (sz <= REGSIZE) @@ -5512,11 +5511,11 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) { // opmv = tyuns(tym) ? MOVZXw : MOVSXw; // MOVZX/MOVSX } - loadea(cdb, e, &cs, opmv, reg, 0, RMload, 0); + loadea(cdb, e, cs, opmv, reg, 0, RMload, 0); } else if (sz <= 2 * REGSIZE && forregs & mES) { - loadea(cdb, e, &cs, 0xC4, reg, 0, 0, mES); // LES data + loadea(cdb, e, cs, 0xC4, reg, 0, 0, mES); // LES data } else if (sz <= 2 * REGSIZE) { @@ -5530,7 +5529,7 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) int i = DOUBLESIZE - REGSIZE; do { - loadea(cdb,e,&cs,0xFF,6,i,0,0); // PUSH EA+i + loadea(cdb,e,cs,0xFF,6,i,0,0); // PUSH EA+i cdb.genadjesp(REGSIZE); cgstate.stackpush += REGSIZE; i -= REGSIZE; @@ -5541,11 +5540,11 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) } reg = findregmsw(forregs); - loadea(cdb, e, &cs, 0x8B, reg, REGSIZE, forregs, 0); // MOV reg,data+2 + loadea(cdb, e, cs, 0x8B, reg, REGSIZE, forregs, 0); // MOV reg,data+2 if (I32 && sz == REGSIZE + 2) cdb.last().Iflags |= CFopsize; // seg is 16 bits reg = findreglsw(forregs); - loadea(cdb, e, &cs, 0x8B, reg, 0, forregs, 0); // MOV reg,data + loadea(cdb, e, cs, 0x8B, reg, 0, forregs, 0); // MOV reg,data } else if (sz >= 8) { @@ -5557,7 +5556,7 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) int i = sz - REGSIZE; do { - loadea(cdb,e,&cs,0xFF,6,i,0,0); // PUSH EA+i + loadea(cdb,e,cs,0xFF,6,i,0,0); // PUSH EA+i cdb.genadjesp(REGSIZE); cgstate.stackpush += REGSIZE; i -= REGSIZE; @@ -5568,10 +5567,10 @@ void loaddata(ref CodeBuilder cdb, elem* e, ref regm_t outretregs) else { assert(reg == AX); - loadea(cdb, e, &cs, 0x8B, AX, 6, 0, 0); // MOV AX,data+6 - loadea(cdb, e, &cs, 0x8B, BX, 4, mAX, 0); // MOV BX,data+4 - loadea(cdb, e, &cs, 0x8B, CX, 2, mAX|mBX, 0); // MOV CX,data+2 - loadea(cdb, e, &cs, 0x8B, DX, 0, mAX|mCX|mCX, 0); // MOV DX,data + loadea(cdb, e, cs, 0x8B, AX, 6, 0, 0); // MOV AX,data+6 + loadea(cdb, e, cs, 0x8B, BX, 4, mAX, 0); // MOV BX,data+4 + loadea(cdb, e, cs, 0x8B, CX, 2, mAX|mBX, 0); // MOV CX,data+2 + loadea(cdb, e, cs, 0x8B, DX, 0, mAX|mCX|mCX, 0); // MOV DX,data } } else diff --git a/compiler/src/dmd/backend/x86/cod2.d b/compiler/src/dmd/backend/x86/cod2.d index 07457c936e28..753b8fb2b095 100644 --- a/compiler/src/dmd/backend/x86/cod2.d +++ b/compiler/src/dmd/backend/x86/cod2.d @@ -829,7 +829,7 @@ void cdorth(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) goto L2; if (!test) getregs(cdb,retregs); // we will trash these regs - loadea(cdb,e2,&cs,op1, + loadea(cdb,e2,cs,op1, ((numwords == 2) ? findreglsw(retregs) : reg), 0,retregs,retregs); if (!I16 && word) @@ -850,7 +850,7 @@ void cdorth(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) cdb.gen(&cs); // ADC reg,data+2 } else - loadea(cdb,e2,&cs,op2,reg,REGSIZE,retregs,0); + loadea(cdb,e2,cs,op2,reg,REGSIZE,retregs,0); } else if (I64 && sz == 8) code_orrex(cdb.last(), REX_W); @@ -957,7 +957,7 @@ void cdmul(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) (e2.E1.Eoper == OPind && !e2.E1.Ecount) ) { - loadea(cdb,e2.E1,&cs,0xF7,opx,0,mAX,mAX | mDX); + loadea(cdb,e2.E1,cs,0xF7,opx,0,mAX,mAX | mDX); } else { @@ -1212,7 +1212,7 @@ void cdmul(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) retregs = ALLREGS; codelem(cgstate,cdb,e1,&retregs,false); // eval left leaf regm_t resreg = retregs; - loadea(cdb,e2,&cs,0x0FAF,findreg(resreg),0,retregs,retregs); + loadea(cdb,e2,cs,0x0FAF,findreg(resreg),0,retregs,retregs); freenode(e2); fixresult(cdb,e,resreg,*pretregs); return; @@ -1231,12 +1231,12 @@ void cdmul(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) const reg = findreg(retregs); getregs(cdb,mAX); genmovreg(cdb,AX,reg); // MOV AX,reg - loadea(cdb,e2,&cs,0xF7,4,REGSIZE,mAX | mDX | mskl(reg),mAX | mDX); // MUL EA+2 + loadea(cdb,e2,cs,0xF7,4,REGSIZE,mAX | mDX | mskl(reg),mAX | mDX); // MUL EA+2 getregs(cdb,retregs); cdb.gen1(0x90 + reg); // XCHG AX,reg getregs(cdb,mAX | mDX); if ((cs.Irm & 0xC0) == 0xC0) // if EA is a register - loadea(cdb,e2,&cs,0xF7,4,0,mAX | mskl(reg),mAX | mDX); // MUL EA + loadea(cdb,e2,cs,0xF7,4,0,mAX | mskl(reg),mAX | mDX); // MUL EA else { getlvalue_lsw(cs); cdb.gen(&cs); // MUL EA @@ -1253,7 +1253,7 @@ void cdmul(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) // loadea() handles CWD or CLR DX for divides regm_t retregs = sz <= REGSIZE ? mAX : mDX|mAX; codelem(cgstate,cdb,e.E1,&retregs,false); // eval left leaf - loadea(cdb,e2,&cs,0xF7 ^ isbyte,5 - uns,0, + loadea(cdb,e2,cs,0xF7 ^ isbyte,5 - uns,0, mAX, mAX | mDX); freenode(e2); @@ -1938,7 +1938,7 @@ void cddiv(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) // loadea() handles CWD or CLR DX for divides regm_t retregs = mAX; codelem(cgstate,cdb,e.E1,&retregs,false); // eval left leaf - loadea(cdb,e2,&cs,0xF7 ^ isbyte,7 - uns,0, + loadea(cdb,e2,cs,0xF7 ^ isbyte,7 - uns,0, mAX | mDX, mAX | mDX); freenode(e2); @@ -4924,7 +4924,7 @@ void getoffset(ref CGstate cg, ref CodeBuilder cdb,elem *e,reg_t reg) const regx = allocreg(cdb,retregs,TYoffset); reg = findreg(retregs); - loadea(cdb,e,&cs,LEA,reg,0,0,0); // LEA reg,EA + loadea(cdb,e,cs,LEA,reg,0,0,0); // LEA reg,EA if (I64) code_orrex(cdb.last(), REX_W); cdb.gen1(0x50 + (reg & 7)); // PUSH reg @@ -4935,7 +4935,7 @@ void getoffset(ref CGstate cg, ref CodeBuilder cdb,elem *e,reg_t reg) } else { - loadea(cdb,e,&cs,LEA,reg,0,0,0); // LEA reg,EA + loadea(cdb,e,cs,LEA,reg,0,0,0); // LEA reg,EA if (I64) code_orrex(cdb.last(), REX_W); } diff --git a/compiler/src/dmd/backend/x86/cod4.d b/compiler/src/dmd/backend/x86/cod4.d index 83836835ac9d..2ba585693f87 100644 --- a/compiler/src/dmd/backend/x86/cod4.d +++ b/compiler/src/dmd/backend/x86/cod4.d @@ -3057,14 +3057,14 @@ void cdcmp(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) { reg = findreg(retregs & cgstate.allregs); // get reg that e1 is in uint opsize = cs.Iflags & CFopsize; - loadea(cdb,e2,&cs,0x3B ^ isbyte ^ reverse,reg,0,RMload | retregs,0); + loadea(cdb,e2,cs,0x3B ^ isbyte ^ reverse,reg,0,RMload | retregs,0); code_orflag(cdb.last(),opsize); } else if (sz <= 2 * REGSIZE) { reg = findregmsw(retregs); // get reg that e1 is in // CMP reg,EA - loadea(cdb,e2,&cs,0x3B ^ reverse,reg,REGSIZE,RMload | retregs,0); + loadea(cdb,e2,cs,0x3B ^ reverse,reg,REGSIZE,RMload | retregs,0); if (I32 && sz == 6) cdb.last().Iflags |= CFopsize; // seg is only 16 bits genjmp(cdb,JNE,FLcode, cast(block *) ce); // JNE ce @@ -3076,7 +3076,7 @@ void cdcmp(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) cdb.gen(&cs); } else - loadea(cdb,e2,&cs,0x3B ^ reverse,reg,0,RMload | retregs,0); + loadea(cdb,e2,cs,0x3B ^ reverse,reg,0,RMload | retregs,0); } else assert(0); @@ -3308,9 +3308,9 @@ void longcmp(ref CodeBuilder cdb,elem *e,bool jcond,uint fltarg,code *targ) genmovreg(cdb,msreg,reg); // MOV msreg,reg cdb.genc2(0xC1,modregrm(3,7,msreg),REGSIZE * 8 - 1); // SAR msreg,31 cse_flush(cdb,1); - loadea(cdb,e2,&cs,0x3B,msreg,REGSIZE,mask(reg),0); + loadea(cdb,e2,cs,0x3B,msreg,REGSIZE,mask(reg),0); cdb.append(cdbjmp); - loadea(cdb,e2,&cs,0x3B,reg,0,mask(reg),0); + loadea(cdb,e2,cs,0x3B,reg,0,mask(reg),0); freenode(e2); } else @@ -3318,10 +3318,10 @@ void longcmp(ref CodeBuilder cdb,elem *e,bool jcond,uint fltarg,code *targ) scodelem(cgstate,cdb,e1,&retregs,0,true); // compute left leaf cse_flush(cdb,1); reg = findregmsw(retregs); // get reg that e1 is in - loadea(cdb,e2,&cs,0x3B,reg,REGSIZE,retregs,0); + loadea(cdb,e2,cs,0x3B,reg,REGSIZE,retregs,0); cdb.append(cdbjmp); reg = findreglsw(retregs); - loadea(cdb,e2,&cs,0x3B,reg,0,retregs,0); + loadea(cdb,e2,cs,0x3B,reg,0,retregs,0); freenode(e2); } break; @@ -3627,7 +3627,7 @@ void cdshtlng(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) code cs; reg = allocreg(cdb,retregs,TYint); - loadea(cdb,e1,&cs,LOD,reg,0,retregs,retregs); // MOV Ereg,EA + loadea(cdb,e1,cs,LOD,reg,0,retregs,retregs); // MOV Ereg,EA freenode(e1); } else @@ -3678,7 +3678,7 @@ void cdshtlng(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) retregs = BYTEREGS; reg = allocreg(cdb,retregs,TYint); movregconst(cdb,reg,0,0); // XOR reg,reg - loadea(cdb,e11,&cs,0x8A,reg,0,retregs,retregs); // MOV regL,EA + loadea(cdb,e11,cs,0x8A,reg,0,retregs,retregs); // MOV regL,EA freenode(e11); freenode(e1); } @@ -3696,11 +3696,11 @@ void cdshtlng(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) { assert(I64); // MOVSXD reg,e1 - loadea(cdb,e1,&cs,0x63,reg,0,0,retregs); + loadea(cdb,e1,cs,0x63,reg,0,0,retregs); code_orrex(cdb.last(), REX_W); } else - loadea(cdb,e1,&cs,opcode,reg,0,0,retregs); + loadea(cdb,e1,cs,opcode,reg,0,0,retregs); freenode(e1); } else @@ -3827,12 +3827,12 @@ void cdbyteint(ref CGstate cg, ref CodeBuilder cdb,elem *e,regm_t *pretregs) config.target_cpu < TARGET_PentiumPro) { movregconst(cdb,reg,0,0); // XOR reg,reg - loadea(cdb,e1,&cs,0x8A,reg,0,retregsx,retregsx); // MOV regL,EA + loadea(cdb,e1,cs,0x8A,reg,0,retregsx,retregsx); // MOV regL,EA } else { const opcode = (op == OPu8_16) ? MOVZXb : MOVSXb; // MOVZX/MOVSX reg,EA - loadea(cdb,e1,&cs,opcode,reg,0,0,retregsx); + loadea(cdb,e1,cs,opcode,reg,0,0,retregsx); } freenode(e1); fixresult(cdb,e,retregsx,*pretregs);