From: MaartenBrock Date: Fri, 12 May 2006 15:01:17 +0000 (+0000) Subject: * doc/sdccman.lyx: documented numeric ranges, WEBDOC #1442369 X-Git-Url: https://git.gag.com/?a=commitdiff_plain;h=8537aed5579845ee84b689333af2e2567037eeae;p=fw%2Fsdcc * doc/sdccman.lyx: documented numeric ranges, WEBDOC #1442369 * device/include/ds80c390.h: added sfr16 definitions * src/ds390/gen.c, * src/ds390/gen.h, * src/ds390/main.c, * src/ds390/ralloc.c, * src/ds390/ralloc.h: changes all over the place to sync with mcs51 fixing several bugs and adding sfr16/sfr32, reentrant bit params, bit returning functions * support/regression/tests/sfr16.c: enabled test on ds390 git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@4169 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- diff --git a/ChangeLog b/ChangeLog index b2bb74c8..fd5ac8b4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,16 @@ +2006-05-12 Maarten Brock + + * doc/sdccman.lyx: documented numeric ranges, WEBDOC #1442369 + * device/include/ds80c390.h: added sfr16 definitions + * src/ds390/gen.c, + * src/ds390/gen.h, + * src/ds390/main.c, + * src/ds390/ralloc.c, + * src/ds390/ralloc.h: changes all over the place to sync with mcs51 + fixing several bugs and adding sfr16/sfr32, reentrant bit params, + bit returning functions + * support/regression/tests/sfr16.c: enabled test on ds390 + 2006-05-11 Erik Petrich * src/hc08/gen.c (asmopToBool, genIfx): fix for bug #1429722 diff --git a/device/include/ds80c390.h b/device/include/ds80c390.h index 44dbe6f0..05dc4cf2 100755 --- a/device/include/ds80c390.h +++ b/device/include/ds80c390.h @@ -180,4 +180,11 @@ __sfr __at 0xf8 EIP; // extended interrupt priority __sbit __at 0xfe C0IP; __sbit __at 0xff CANBIP; +/* WORD/DWORD Registers */ + +__sfr16 __at (0x8C8A) TMR0 ; /* TIMER 0 COUNTER */ +__sfr16 __at (0x8D8B) TMR1 ; /* TIMER 1 COUNTER */ +__sfr16 __at (0xCDCC) TMR2 ; /* TIMER 2 COUNTER */ +__sfr16 __at (0xCBCA) RCAP2 ; /* TIMER 2 CAPTURE REGISTER WORD */ + #endif /* DS80C390_H */ diff --git a/doc/sdccman.lyx b/doc/sdccman.lyx index 353506e9..014985e8 100644 --- a/doc/sdccman.lyx +++ b/doc/sdccman.lyx @@ -202,21 +202,355 @@ The peep hole optimizer uses a rule based substitution mechanism which is \newline Supported data-types are: -\layout Itemize +\layout Standard -char (8 bits, 1 byte), -\layout Itemize -short and int (16 bits, 2 bytes), -\layout Itemize +\begin_inset Tabular + + + + + + + + + +\begin_inset Text -long (32 bit, 4 bytes) -\layout Itemize +\layout Standard + +type +\end_inset + + +\begin_inset Text + +\layout Standard + +width +\end_inset + + +\begin_inset Text + +\layout Standard + +default +\end_inset + + +\begin_inset Text + +\layout Standard + +signed range +\end_inset + + +\begin_inset Text + +\layout Standard + +unsigned range +\end_inset + + + + +\begin_inset Text + +\layout Standard + +bool +\end_inset + + +\begin_inset Text + +\layout Standard + +1 bit +\end_inset + + +\begin_inset Text + +\layout Standard + +unsigned +\end_inset + + +\begin_inset Text + +\layout Standard + +- +\end_inset + + +\begin_inset Text + +\layout Standard + +0, 1 +\end_inset + + + + +\begin_inset Text + +\layout Standard + +char +\end_inset + + +\begin_inset Text + +\layout Standard + +8 bits, 1 byte +\end_inset + + +\begin_inset Text + +\layout Standard + +signed +\end_inset + + +\begin_inset Text + +\layout Standard + +-128, +127 +\end_inset + + +\begin_inset Text + +\layout Standard + +0, +255 +\end_inset + + + + +\begin_inset Text + +\layout Standard + +short +\end_inset + + +\begin_inset Text + +\layout Standard + +16 bits, 2 bytes +\end_inset + + +\begin_inset Text + +\layout Standard + +signed +\end_inset + + +\begin_inset Text + +\layout Standard + +-32.768, +32.767 +\end_inset + + +\begin_inset Text + +\layout Standard + +0, +65.535 +\end_inset + + + + +\begin_inset Text -float (4 byte IEEE). - \layout Standard +int +\end_inset + + +\begin_inset Text + +\layout Standard + +16 bits, 2 bytes +\end_inset + + +\begin_inset Text + +\layout Standard + +signed +\end_inset + + +\begin_inset Text + +\layout Standard + +-32.768, +32.767 +\end_inset + + +\begin_inset Text + +\layout Standard + +0, +65.535 +\end_inset + + + + +\begin_inset Text + +\layout Standard + +long +\end_inset + + +\begin_inset Text + +\layout Standard + +32 bits, 4 bytes +\end_inset + + +\begin_inset Text + +\layout Standard + +signed +\end_inset + + +\begin_inset Text + +\layout Standard + +-2.147.483.648, +2.147.483.647 +\end_inset + + +\begin_inset Text + +\layout Standard + +0, +4.294.967.296 +\end_inset + + + + +\begin_inset Text + +\layout Standard + +float +\end_inset + + +\begin_inset Text + +\layout Standard + +4 bytes IEEE +\end_inset + + +\begin_inset Text + +\layout Standard + +signed +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + +pointer +\end_inset + + +\begin_inset Text + +\layout Standard + +1, 2, 3 or 4 bytes +\end_inset + + +\begin_inset Text + +\layout Standard + +generic +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\end_inset + + +\newline The compiler also allows \emph on inline assembler code diff --git a/src/ds390/gen.c b/src/ds390/gen.c index 4b587102..28173930 100644 --- a/src/ds390/gen.c +++ b/src/ds390/gen.c @@ -25,17 +25,20 @@ what you give them. Help stamp out software-hoarding! -------------------------------------------------------------------------*/ +//#define D(x) +#define D(x) x + #include #include #include #include +#include "SDCCglobl.h" +#include "newalloc.h" #include "common.h" #include "main.h" #include "ralloc.h" #include "gen.h" -#include "SDCCglobl.h" -#include "newalloc.h" #define BETTER_LITERAL_SHIFT @@ -51,12 +54,10 @@ static char *zero = "#0"; static char *one = "#1"; static char *spname; -#define D(x) x - #define TR_DPTR(s) if (options.model != MODEL_FLAT24) { emitcode(";", " Use_DPTR1 %s ", s); } #define TR_AP(s) if (options.model != MODEL_FLAT24) { emitcode(";", " Use_AP %s ", s); } -short fReturnSizeDS390 = 5; +unsigned fReturnSizeDS390 = 5; static char *fReturn24[] = {"dpl", "dph", "dpx", "b", "a"}; static char *fReturn16[] = @@ -68,12 +69,77 @@ static char *dptrn[2][3]; static char *javaRet[] = { "r0","r1","r2","r3"}; static short rbank = -1; +#define REG_WITH_INDEX ds390_regWithIdx + +#define AOP(op) op->aop +#define AOP_TYPE(op) AOP(op)->type +#define AOP_SIZE(op) AOP(op)->size +#define IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \ + AOP_TYPE(x) == AOP_R0)) + +#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \ + AOP_TYPE(x) == AOP_DPTR || AOP_TYPE(x) == AOP_DPTR2 || \ + AOP(x)->paged)) + +#define AOP_INPREG(x) (x && (x->type == AOP_REG && \ + (x->aopu.aop_reg[0] == REG_WITH_INDEX(R0_IDX) || \ + x->aopu.aop_reg[0] == REG_WITH_INDEX(R1_IDX) ))) +#define AOP_INDPTRn(x) (AOP_TYPE(x) == AOP_DPTRn) +#define AOP_USESDPTR(x) ((AOP_TYPE(x) == AOP_DPTR) || (AOP_TYPE(x) == AOP_STR)) +#define AOP_USESDPTR2(x) ((AOP_TYPE(x) == AOP_DPTR2) || (AOP_TYPE(x) == AOP_DPTRn)) + +// The following two macros can be used even if the aop has not yet been aopOp'd. +#define AOP_IS_STR(x) (IS_SYMOP(x) && OP_SYMBOL(x)->ruonly) +#define AOP_IS_DPTRn(x) (IS_SYMOP(x) && OP_SYMBOL(x)->dptr) + +/* Workaround for DS80C390 bug: div ab may return bogus results + * if A is accessed in instruction immediately before the div. + * + * Will be fixed in B4 rev of processor, Dallas claims. + */ + +#define LOAD_AB_FOR_DIV(LEFT, RIGHT, L) \ + if (!AOP_NEEDSACC(RIGHT)) \ + { \ + /* We can load A first, then B, since \ + * B (the RIGHT operand) won't clobber A, \ + * thus avoiding touching A right before the div. \ + */ \ + D(emitcode(";", "DS80C390 div bug: rearranged ops.");); \ + L = aopGet(LEFT,0,FALSE,FALSE,NULL); \ + MOVA(L); \ + L = aopGet(RIGHT,0,FALSE,FALSE,"b"); \ + MOVB(L); \ + } \ + else \ + { \ + /* Just stuff in a nop after loading A. */ \ + emitcode("mov","b,%s",aopGet(RIGHT,0,FALSE,FALSE,NULL));\ + L = aopGet(LEFT,0,FALSE,FALSE,NULL); \ + MOVA(L); \ + emitcode("nop", "; workaround for DS80C390 div bug."); \ + } + +#define R0INB _G.bu.bs.r0InB +#define R1INB _G.bu.bs.r1InB +#define OPINB _G.bu.bs.OpInB +#define BINUSE _G.bu.BInUse + static struct { short r0Pushed; short r1Pushed; + union + { + struct + { + short r0InB : 2;//2 so we can see it overflow + short r1InB : 2;//2 so we can see it overflow + short OpInB : 2;//2 so we can see it overflow + } bs; + short BInUse; + } bu; short accInUse; - short bInUse; short inLine; short debugLine; short nRegsSaved; @@ -81,11 +147,13 @@ static struct short dptr1InUse; set *sendSet; iCode *current_iCode; + symbol *currentFunc; } _G; static char *rb1regs[] = { - "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7" + "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7", + "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7" }; static void saveRBank (int, iCode *, bool); @@ -94,8 +162,8 @@ static void saveRBank (int, iCode *, bool); (IC_RESULT(x) && IC_RESULT(x)->aop && \ IC_RESULT(x)->aop->type == AOP_STK ) -#define MOVA(x) _movA(x) -#define MOVB(x) _movB(x) +#define MOVA(x) mova(x) /* use function to avoid multiple eval */ +#define MOVB(x) movb(x) #define CLRC emitcode("clr","c") #define SETC emitcode("setb","c") @@ -126,10 +194,7 @@ static unsigned char SRMask[] = emitcode ("","!tlabeldef",lbl->key+100); \ }} #define UNPROTECT_SP { if (options.protect_sp_update) { \ - symbol *lbl = newiTempLabel(NULL); \ - emitcode ("jnb","F1,!tlabel",lbl->key+100); \ - emitcode ("setb","EA"); \ - emitcode ("","!tlabeldef",lbl->key+100); \ + emitcode ("mov","EA,F1"); \ }} static int _currentDPS; /* Current processor DPS. */ @@ -197,28 +262,121 @@ ds390_emitDebuggerSymbol (char * debugSym) _G.debugLine = 0; } -// -// Move the passed value into A unless it is already there. -// +/*-----------------------------------------------------------------*/ +/* mova - moves specified value into accumulator */ +/*-----------------------------------------------------------------*/ +static void +mova (const char *x) +{ + /* do some early peephole optimization */ + if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4)) + return; + + emitcode("mov", "a,%s", x); +} + +/*-----------------------------------------------------------------*/ +/* movb - moves specified value into register b */ +/*-----------------------------------------------------------------*/ +static void +movb (const char *x) +{ + /* do some early peephole optimization */ + if (!strncmp(x, "b", 2)) + return; + + emitcode("mov","b,%s", x); +} + +/*-----------------------------------------------------------------*/ +/* movc - moves specified value into the carry */ +/*-----------------------------------------------------------------*/ static void -_movA(const char *s) +movc (const char *s) { - if (strcmp(s,"a") && strcmp(s,"acc")) + if (s == zero) + CLRC; + else if (s == one) + SETC; + else if (strcmp (s, "c")) + {/* it's not in carry already */ + MOVA (s); + /* set C, if a >= 1 */ + emitcode ("add", "a,#0xff"); + } +} + +/*-----------------------------------------------------------------*/ +/* pushB - saves register B if necessary */ +/*-----------------------------------------------------------------*/ +static bool +pushB (void) +{ + bool pushedB = FALSE; + + if (BINUSE) { - emitcode("mov","a,%s",s); + emitcode ("push", "b"); +// printf("B was in use !\n"); + pushedB = TRUE; } + else + { + OPINB++; + } + return pushedB; } -// -// Move the passed value into B unless it is already there. -// +/*-----------------------------------------------------------------*/ +/* popB - restores value of register B if necessary */ +/*-----------------------------------------------------------------*/ static void -_movB(const char *s) +popB (bool pushedB) { - if (strcmp(s,"b")) + if (pushedB) { - emitcode("mov","b,%s",s); + emitcode ("pop", "b"); } + else + { + OPINB--; + } +} + +/*-----------------------------------------------------------------*/ +/* pushReg - saves register */ +/*-----------------------------------------------------------------*/ +static bool +pushReg (int index, bool bits_pushed) +{ + regs * reg = REG_WITH_INDEX (index); + if (reg->type == REG_BIT) + { + if (!bits_pushed) + emitcode ("push", "%s", reg->base); + return TRUE; + } + else + emitcode ("push", "%s", reg->dname); + return bits_pushed; +} + +/*-----------------------------------------------------------------*/ +/* popReg - restores register */ +/*-----------------------------------------------------------------*/ +static bool +popReg (int index, bool bits_popped) +{ + regs * reg = REG_WITH_INDEX (index); + if (reg->type == REG_BIT) + { + if (!bits_popped) + emitcode ("pop", "%s", reg->base); + return TRUE; + } + else + emitcode ("pop", "%s", reg->dname); + return bits_popped; } /*-----------------------------------------------------------------*/ @@ -250,7 +408,7 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX); (*aopp)->type = AOP_R0; - return (*aopp)->aopu.aop_ptr = ds390_regWithIdx (R0_IDX); + return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R0_IDX); } /* if no usage of r1 then return it */ @@ -259,7 +417,7 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX); (*aopp)->type = AOP_R1; - return (*aopp)->aopu.aop_ptr = ds390_regWithIdx (R1_IDX); + return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R1_IDX); } /* now we know they both have usage */ @@ -270,14 +428,14 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) if (!_G.r0Pushed) { emitcode ("push", "%s", - ds390_regWithIdx (R0_IDX)->dname); + REG_WITH_INDEX (R0_IDX)->dname); _G.r0Pushed++; } ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX); (*aopp)->type = AOP_R0; - return (*aopp)->aopu.aop_ptr = ds390_regWithIdx (R0_IDX); + return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R0_IDX); } /* if r1 not used then */ @@ -288,17 +446,17 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) if (!_G.r1Pushed) { emitcode ("push", "%s", - ds390_regWithIdx (R1_IDX)->dname); + REG_WITH_INDEX (R1_IDX)->dname); _G.r1Pushed++; } ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX); (*aopp)->type = AOP_R1; - return ds390_regWithIdx (R1_IDX); + return REG_WITH_INDEX (R1_IDX); } endOfWorld: - /* I said end of world but not quite end of world yet */ + /* I said end of world, but not quite end of world yet */ /* if this is a result then we can push it on the stack */ if (result) { @@ -306,7 +464,7 @@ endOfWorld: return NULL; } - /* other wise this is true end of the world */ + /* now this is REALLY the end of the world */ werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "getFreePtr should never reach here"); exit (1); @@ -314,19 +472,6 @@ endOfWorld: return NULL; // notreached, but makes compiler happy. } -/*-----------------------------------------------------------------*/ -/* newAsmop - creates a new asmOp */ -/*-----------------------------------------------------------------*/ -static asmop * -newAsmop (short type) -{ - asmop *aop; - - aop = Safe_calloc (1, sizeof (asmop)); - aop->type = type; - return aop; -} - /*-----------------------------------------------------------------*/ /* genSetDPTR: generate code to select which DPTR is in use (zero */ @@ -357,23 +502,23 @@ genSetDPTR (int n) } } -/*-----------------------------------------------------------------*/ +/*------------------------------------------------------------------*/ /* _startLazyDPSEvaluation: call to start doing lazy DPS evaluation */ -/* */ -/* Any code that operates on DPTR (NB: not on the individual */ -/* components, like DPH) *must* call _flushLazyDPS() before using */ -/* DPTR within a lazy DPS evaluation block. */ -/* */ -/* Note that aopPut and aopGet already contain the proper calls to */ -/* _flushLazyDPS, so it is safe to use these calls within a lazy */ -/* DPS evaluation block. */ -/* */ -/* Also, _flushLazyDPS must be called before any flow control */ -/* operations that could potentially branch out of the block. */ -/* */ -/* Lazy DPS evaluation is simply an optimization (though an */ -/* important one), so if in doubt, leave it out. */ -/*-----------------------------------------------------------------*/ +/* */ +/* Any code that operates on DPTR (NB: not on the individual */ +/* components, like DPH) *must* call _flushLazyDPS() before using */ +/* DPTR within a lazy DPS evaluation block. */ +/* */ +/* Note that aopPut and aopGet already contain the proper calls to */ +/* _flushLazyDPS, so it is safe to use these calls within a lazy */ +/* DPS evaluation block. */ +/* */ +/* Also, _flushLazyDPS must be called before any flow control */ +/* operations that could potentially branch out of the block. */ +/* */ +/* Lazy DPS evaluation is simply an optimization (though an */ +/* important one), so if in doubt, leave it out. */ +/*------------------------------------------------------------------*/ static void _startLazyDPSEvaluation (void) { @@ -386,11 +531,11 @@ _startLazyDPSEvaluation (void) #endif } -/*-----------------------------------------------------------------*/ -/* _flushLazyDPS: emit code to force the actual DPS setting to the */ +/*------------------------------------------------------------------*/ +/* _flushLazyDPS: emit code to force the actual DPS setting to the */ /* desired one. Call before using DPTR within a lazy DPS evaluation */ -/* block. */ -/*-----------------------------------------------------------------*/ +/* block. */ +/*------------------------------------------------------------------*/ static void _flushLazyDPS (void) { @@ -440,6 +585,19 @@ _endLazyDPSEvaluation (void) } +/*-----------------------------------------------------------------*/ +/* newAsmop - creates a new asmOp */ +/*-----------------------------------------------------------------*/ +static asmop * +newAsmop (short type) +{ + asmop *aop; + + aop = Safe_calloc (1, sizeof (asmop)); + aop->type = type; + aop->allocated = 1; + return aop; +} /*-----------------------------------------------------------------*/ /* pointerCode - returns the code for a pointer type */ @@ -525,8 +683,16 @@ static asmop * aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2) { asmop *aop; - memmap *space = SPEC_OCLS (sym->etype); - int accuse = leftRightUseAcc (ic); + memmap *space; + bool accuse = leftRightUseAcc (ic) || _G.accInUse; + char *dpl = useDP2 ? "dpl1" : "dpl"; + char *dph = useDP2 ? "dph1" : "dph"; + char *dpx = useDP2 ? "dpx1" : "dpx"; + + wassertl (ic != NULL, "Got a null iCode"); + wassertl (sym != NULL, "Got a null symbol"); + + space = SPEC_OCLS (sym->etype); /* if already has one */ if (sym->aop) @@ -535,7 +701,10 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2) || (sym->aop->type == AOP_DPTR2 && !useDP2)) sym->aop = NULL; else - return sym->aop; + { + sym->aop->allocated++; + return sym->aop; + } } /* assign depending on the storage class */ @@ -551,33 +720,45 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2) the pointer register */ if (aop->type != AOP_STK) { - if (sym->onStack) { - if (_G.accInUse || accuse) - emitcode ("push", "acc"); - - if (_G.bInUse || (accuse>1)) - emitcode ("push", "b"); - - emitcode ("mov", "a,_bp"); - emitcode ("add", "a,#!constbyte", - ((sym->stack < 0) ? + char offset = ((sym->stack < 0) ? ((char) (sym->stack - _G.nRegsSaved)) : - ((char) sym->stack)) & 0xff); - emitcode ("mov", "%s,a", - aop->aopu.aop_ptr->name); - - if (_G.bInUse || (accuse>1)) - emitcode ("pop", "b"); + ((char) sym->stack)) & 0xff; - if (_G.accInUse || accuse) - emitcode ("pop", "acc"); + if ((abs(offset) <= 3) || + (accuse && (abs(offset) <= 7))) + { + emitcode ("mov", "%s,_bp", + aop->aopu.aop_ptr->name); + while (offset < 0) + { + emitcode ("dec", aop->aopu.aop_ptr->name); + offset++; + } + while (offset > 0) + { + emitcode ("inc", aop->aopu.aop_ptr->name); + offset--; + } + } + else + { + if (accuse) + emitcode ("push", "acc"); + emitcode ("mov", "a,_bp"); + emitcode ("add", "a,#!constbyte", offset); + emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name); + if (accuse) + emitcode ("pop", "acc"); + } } else - emitcode ("mov", "%s,#%s", - aop->aopu.aop_ptr->name, - sym->rname); + { + emitcode ("mov", "%s,#%s", + aop->aopu.aop_ptr->name, + sym->rname); + } aop->paged = space->paged; } else @@ -590,85 +771,58 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2) short stack_val = -((sym->stack < 0) ? ((short) (sym->stack - _G.nRegsSaved)) : ((short) sym->stack)) ; - if (useDP2 && _G.dptr1InUse) { - emitcode ("push","dpl1"); - emitcode ("push","dph1"); - emitcode ("push","dpx1"); - } else if (_G.dptrInUse ) { - emitcode ("push","dpl"); - emitcode ("push","dph"); - emitcode ("push","dpx"); + if (_G.dptrInUse ) { + emitcode ("push",dpl); + emitcode ("push",dph); + emitcode ("push",dpx); } /* It's on the 10 bit stack, which is located in * far data space. */ - if (stack_val < 0 && stack_val > -5) { /* between -5 & -1 */ - if (useDP2) { - if (options.model == MODEL_FLAT24) - { - emitcode ("mov", "dpx1,#!constbyte", - (options.stack_loc >> 16) & 0xff); - } - emitcode ("mov", "dph1,_bpx+1"); - - emitcode ("mov", "dpl1,_bpx"); - emitcode ("mov","dps,#1"); - } else { - if (options.model == MODEL_FLAT24) - { - emitcode ("mov", "dpx,#!constbyte", - (options.stack_loc >> 16) & 0xff); - } - emitcode ("mov", "dph,_bpx+1"); - emitcode ("mov", "dpl,_bpx"); - } - stack_val = -stack_val; - while (stack_val--) { - emitcode ("inc","dptr"); - } - if (useDP2) { - emitcode("mov","dps,#0"); - } - } else { - if (_G.accInUse || accuse) - emitcode ("push", "acc"); - - if (_G.bInUse || (accuse>1)) - emitcode ("push", "b"); - - emitcode ("mov", "a,_bpx"); - emitcode ("clr","c"); - emitcode ("subb", "a,#!constbyte", stack_val & 0xff); - emitcode ("mov","b,a"); - emitcode ("mov","a,_bpx+1"); - emitcode ("subb","a,#!constbyte",(stack_val >> 8) & 0xff); - if (useDP2) { - if (options.model == MODEL_FLAT24) - { - emitcode ("mov", "dpx1,#!constbyte", - (options.stack_loc >> 16) & 0xff); - } - emitcode ("mov", "dph1,a"); - emitcode ("mov", "dpl1,b"); - } else { - if (options.model == MODEL_FLAT24) - { - emitcode ("mov", "dpx,#!constbyte", - (options.stack_loc >> 16) & 0xff); - } - emitcode ("mov", "dph,a"); - emitcode ("mov", "dpl,b"); + if (stack_val < 0 && stack_val > -5) + { /* between -5 & -1 */ + if (options.model == MODEL_FLAT24) + { + emitcode ("mov", "%s,#!constbyte", dpx, + (options.stack_loc >> 16) & 0xff); } + emitcode ("mov", "%s,_bpx+1", dph); + emitcode ("mov", "%s,_bpx", dpl); + if (useDP2) { + emitcode ("mov","dps,#1"); + } + stack_val = -stack_val; + while (stack_val--) { + emitcode ("inc","dptr"); + } + if (useDP2) { + emitcode("mov","dps,#0"); + } + } + else + { + if (accuse) + emitcode ("push", "acc"); - if (_G.bInUse || (accuse>1)) - emitcode ("pop", "b"); + emitcode ("mov", "a,_bpx"); + emitcode ("clr","c"); + emitcode ("subb", "a,#!constbyte", stack_val & 0xff); + emitcode ("mov","%s,a", dpl); + emitcode ("mov","a,_bpx+1"); + emitcode ("subb","a,#!constbyte",(stack_val >> 8) & 0xff); + emitcode ("mov", "%s,a", dph); + if (options.model == MODEL_FLAT24) + { + emitcode ("mov", "%s,#!constbyte", dpx, + (options.stack_loc >> 16) & 0xff); + } - if (_G.accInUse || accuse) - emitcode ("pop", "acc"); + if (accuse) + emitcode ("pop", "acc"); } - sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR)); - aop->size = getSize (sym->type); - return aop; + sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR)); + aop->size = getSize (sym->type); + return aop; } /* if in bit space */ @@ -751,7 +905,7 @@ aopForRemat (symbol * sym) if (val) { SNPRINTF (buffer, sizeof(buffer), - "(%s %c 0x%04x)", + "(%s %c 0x%06x)", OP_SYMBOL (IC_LEFT (ic))->rname, val >= 0 ? '+' : '-', abs (val) & 0xffffff); @@ -792,7 +946,7 @@ static int aopHasRegs(asmop *aop, int from, int to) for (; size < aop->size ; size++) { int reg; for (reg = from ; reg <= to ; reg++) - if (aop->aopu.aop_reg[size] == ds390_regWithIdx(reg)) return 1; + if (aop->aopu.aop_reg[size] == REG_WITH_INDEX(reg)) return 1; } return 0; } @@ -843,7 +997,7 @@ operandsEqu (operand * op1, operand * op2) { symbol *sym1, *sym2; - /* if they not symbols */ + /* if they're not symbols */ if (!IS_SYMOP (op1) || !IS_SYMOP (op2)) return FALSE; @@ -860,8 +1014,10 @@ operandsEqu (operand * op1, operand * op2) if (sym1 == sym2) return TRUE; - if (sym1->rname[0] && sym2->rname[0] - && strcmp (sym1->rname, sym2->rname) == 0) + /* if they have the same rname */ + if (sym1->rname[0] && sym2->rname[0] && + strcmp (sym1->rname, sym2->rname) == 0 && + !(IS_PARM (op2) && IS_ITEMP (op1))) return TRUE; /* if left is a tmp & right is not */ @@ -906,16 +1062,17 @@ sameRegs (asmop * aop1, asmop * aop2) return TRUE; } - if (aop1->type != AOP_REG || - aop2->type != AOP_REG) + if (aop1->type != AOP_REG && aop1->type != AOP_CRY) + return FALSE; + + if (aop1->type != aop2->type) return FALSE; if (aop1->size != aop2->size) return FALSE; for (i = 0; i < aop1->size; i++) - if (aop1->aopu.aop_reg[i] != - aop2->aopu.aop_reg[i]) + if (aop1->aopu.aop_reg[i] != aop2->aopu.aop_reg[i]) return FALSE; return TRUE; @@ -950,7 +1107,10 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2) || (op->aop->type == AOP_DPTR2 && !useDP2)) op->aop = NULL; else - return; + { + op->aop->allocated++; + return; + } } /* if the underlying symbol has a aop */ @@ -961,7 +1121,10 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2) || (op->aop->type == AOP_DPTR2 && !useDP2)) op->aop = NULL; else - return; + { + op->aop->allocated++; + return; + } } /* if this is a true symbol */ @@ -972,7 +1135,7 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2) } /* this is a temporary : this has - only four choices : + only five choices : a) register b) spillocation c) rematerialize @@ -1016,7 +1179,7 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2) if (sym->ruonly) { - int i; + unsigned i; if (useDP2) { @@ -1059,6 +1222,16 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2) return; } + /* if the type is a bit register */ + if (sym->regType == REG_BIT) + { + sym->aop = op->aop = aop = newAsmop (AOP_CRY); + aop->size = sym->nRegs;//1??? + aop->aopu.aop_reg[0] = sym->regs[0]; + aop->aopu.aop_dir = sym->regs[0]->name; + return; + } + /* must be in a register */ sym->aop = op->aop = aop = newAsmop (AOP_REG); aop->size = sym->nRegs; @@ -1082,13 +1255,13 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) if (!aop) return; - if (aop->freed) - goto dealloc; + aop->allocated--; - aop->freed = 1; + if (aop->allocated) + goto dealloc; - /* depending on the asmop type only three cases need work AOP_RO - , AOP_R1 && AOP_STK */ + /* depending on the asmop type only three cases need work + AOP_R0, AOP_R1 & AOP_STK */ switch (aop->type) { case AOP_R0: @@ -1154,17 +1327,16 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) } op->aop = aop; freeAsmop (op, NULL, ic, TRUE); - if (_G.r0Pushed) - { - emitcode ("pop", "ar0"); - _G.r0Pushed--; - } - if (_G.r1Pushed) { emitcode ("pop", "ar1"); _G.r1Pushed--; } + if (_G.r0Pushed) + { + emitcode ("pop", "ar0"); + _G.r0Pushed--; + } } case AOP_DPTR2: if (_G.dptr1InUse) { @@ -1181,6 +1353,7 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) } break; } + dealloc: /* all other cases just dealloc */ if (op) @@ -1199,6 +1372,57 @@ dealloc: #define DEFAULT_ACC_WARNING 0 static int saveAccWarn = DEFAULT_ACC_WARNING; + +/*-----------------------------------------------------------------*/ +/* aopGetUsesAcc - indicates ahead of time whether aopGet() will */ +/* clobber the accumulator */ +/*-----------------------------------------------------------------*/ +static bool +aopGetUsesAcc (operand * oper, int offset) +{ + asmop * aop = AOP (oper); + + if (offset > (aop->size - 1)) + return FALSE; + + switch (aop->type) + { + + case AOP_R0: + case AOP_R1: + if (aop->paged) + return TRUE; + return FALSE; + case AOP_DPTR: + return TRUE; + case AOP_IMMD: + return FALSE; + case AOP_DIR: + return FALSE; + case AOP_REG: + wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a")); + return FALSE; + case AOP_CRY: + return TRUE; + case AOP_ACC: + if (offset) + return FALSE; + return TRUE; + case AOP_LIT: + return FALSE; + case AOP_STR: + if (strcmp (aop->aopu.aop_str[offset], "a") == 0) + return TRUE; + return FALSE; + case AOP_DUMMY: + return FALSE; + default: + /* Error case --- will have been caught already */ + wassert(0); + return FALSE; + } +} + /*-------------------------------------------------------------------*/ /* aopGet - for fetching value of the aop */ /* */ @@ -1207,14 +1431,15 @@ static int saveAccWarn = DEFAULT_ACC_WARNING; /* if acc must be preserved; the register will be used to preserve */ /* acc temporarily and to return the result byte. */ /*-------------------------------------------------------------------*/ - static char * -aopGet (asmop *aop, +aopGet (operand * oper, int offset, bool bit16, bool dname, char *saveAcc) { + asmop * aop = AOP (oper); + /* offset is greater than size then zero */ if (offset > (aop->size - 1) && @@ -1359,18 +1584,24 @@ aopGet (asmop *aop, return Safe_strdup(buffer); case AOP_DIR: - if (offset) - { - SNPRINTF (buffer, sizeof(buffer), - "(%s + %d)", - aop->aopu.aop_dir, - offset); - } + if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset) + { + SNPRINTF (buffer, sizeof(buffer), + "(%s >> %d)", + aop->aopu.aop_dir, offset * 8); + } + else if (offset) + { + SNPRINTF (buffer, sizeof(buffer), + "(%s + %d)", + aop->aopu.aop_dir, + offset); + } else - { - SNPRINTF(buffer, sizeof(buffer), - "%s", aop->aopu.aop_dir); - } + { + SNPRINTF (buffer, sizeof(buffer), + "%s", aop->aopu.aop_dir); + } return Safe_strdup(buffer); @@ -1410,12 +1641,60 @@ aopGet (asmop *aop, return NULL; // not reached, but makes compiler happy. } + /*-----------------------------------------------------------------*/ -/* aopPut - puts a string for a aop */ +/* aopPutUsesAcc - indicates ahead of time whether aopPut() will */ +/* clobber the accumulator */ /*-----------------------------------------------------------------*/ -static void -aopPut (asmop * aop, char *s, int offset) +static bool +aopPutUsesAcc (operand * oper, const char *s, int offset) { + asmop * aop = AOP (oper); + + if (offset > (aop->size - 1)) + return FALSE; + + switch (aop->type) + { + case AOP_DUMMY: + return TRUE; + case AOP_DIR: + return FALSE; + case AOP_REG: + wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a")); + return FALSE; + case AOP_DPTR: + return TRUE; + case AOP_R0: + case AOP_R1: + return ((aop->paged) || (*s == '@')); + case AOP_STK: + return (*s == '@'); + case AOP_CRY: + return (!aop->aopu.aop_dir || strcmp(s, aop->aopu.aop_dir)); + case AOP_STR: + return FALSE; + case AOP_IMMD: + return FALSE; + case AOP_ACC: + return FALSE; + default: + /* Error case --- will have been caught already */ + wassert(0); + return FALSE; + } +} + +/*-----------------------------------------------------------------*/ +/* aopPut - puts a string for a aop and indicates if acc is in use */ +/*-----------------------------------------------------------------*/ +static bool +aopPut (operand * result, const char *s, int offset) +{ + bool bvolatile = isOperandVolatile (result, FALSE); + bool accuse = FALSE; + asmop * aop = AOP (result); + if (aop->size && offset > (aop->size - 1)) { werror (E_INTERNAL_ERROR, __FILE__, __LINE__, @@ -1429,26 +1708,36 @@ aopPut (asmop * aop, char *s, int offset) { case AOP_DUMMY: MOVA (s); /* read s in case it was volatile */ + accuse = TRUE; break; case AOP_DIR: - if (offset) + if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset) + { + SNPRINTF (buffer, sizeof(buffer), + "(%s >> %d)", + aop->aopu.aop_dir, offset * 8); + } + else if (offset) { SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", aop->aopu.aop_dir, offset); } - else + else { SNPRINTF (buffer, sizeof(buffer), "%s", aop->aopu.aop_dir); } - - if (strcmp (buffer, s)) + if (strcmp (buffer, s) || bvolatile) { emitcode ("mov", "%s,%s", buffer, s); } + if (!strcmp (buffer, "acc")) + { + accuse = TRUE; + } break; case AOP_REG: @@ -1492,7 +1781,7 @@ aopPut (asmop * aop, char *s, int offset) if (aop->code) { werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "aopPut writting to code space"); + "aopPut writing to code space"); exit (1); } @@ -1510,7 +1799,7 @@ aopPut (asmop * aop, char *s, int offset) aop->coff = offset; - /* if not in accumulater */ + /* if not in accumulator */ MOVA (s); emitcode ("movx", "@dptr,a"); @@ -1539,7 +1828,6 @@ aopPut (asmop * aop, char *s, int offset) { MOVA (s); emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name); - } else if (*s == '@') { @@ -1555,11 +1843,10 @@ aopPut (asmop * aop, char *s, int offset) strcmp (s, "r6") == 0 || strcmp (s, "r7") == 0) { - char buff[10]; - SNPRINTF(buff, sizeof(buff), - "a%s", s); + char buffer[10]; + SNPRINTF (buffer, sizeof(buffer), "a%s", s); emitcode ("mov", "@%s,%s", - aop->aopu.aop_ptr->name, buff); + aop->aopu.aop_ptr->name, buffer); } else { @@ -1581,11 +1868,13 @@ aopPut (asmop * aop, char *s, int offset) break; case AOP_CRY: - /* if bit variable */ + /* if not bit variable */ if (!aop->aopu.aop_dir) { + /* inefficient: move carry into A and use jz/jnz */ emitcode ("clr", "a"); emitcode ("rlc", "a"); + accuse = TRUE; } else { @@ -1595,33 +1884,29 @@ aopPut (asmop * aop, char *s, int offset) emitcode ("setb", "%s", aop->aopu.aop_dir); else if (!strcmp (s, "c")) emitcode ("mov", "%s,c", aop->aopu.aop_dir); - else + else if (strcmp (s, aop->aopu.aop_dir)) { - if (strcmp (s, "a")) - { MOVA (s); - } - { /* set C, if a >= 1 */ emitcode ("add", "a,#!constbyte",0xff); emitcode ("mov", "%s,c", aop->aopu.aop_dir); } } - } break; case AOP_STR: aop->coff = offset; - if (strcmp (aop->aopu.aop_str[offset], s)) + if (strcmp (aop->aopu.aop_str[offset], s) || bvolatile) emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s); break; case AOP_ACC: + accuse = TRUE; aop->coff = offset; - if (!offset && (strcmp (s, "acc") == 0)) + if (!offset && (strcmp (s, "acc") == 0) && !bvolatile) break; - if (strcmp (aop->aopu.aop_str[offset], s)) + if (strcmp (aop->aopu.aop_str[offset], s) && !bvolatile) emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s); break; @@ -1631,6 +1916,7 @@ aopPut (asmop * aop, char *s, int offset) exit (1); } + return accuse; } @@ -1640,9 +1926,8 @@ aopPut (asmop * aop, char *s, int offset) static void reAdjustPreg (asmop * aop) { - if ((aop->coff==0) || (aop->size <= 1)) { + if ((aop->coff==0) || (aop->size <= 1)) return; - } switch (aop->type) { @@ -1668,61 +1953,10 @@ reAdjustPreg (asmop * aop) genSetDPTR (0); } break; - } - aop->coff=0; + aop->coff = 0; } -#define AOP(op) op->aop -#define AOP_TYPE(op) AOP(op)->type -#define AOP_SIZE(op) AOP(op)->size -#define IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \ - AOP_TYPE(x) == AOP_R0)) - -#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \ - AOP_TYPE(x) == AOP_DPTR || AOP_TYPE(x) == AOP_DPTR2 || \ - AOP(x)->paged)) - -#define AOP_INPREG(x) (x && (x->type == AOP_REG && \ - (x->aopu.aop_reg[0] == ds390_regWithIdx(R0_IDX) || \ - x->aopu.aop_reg[0] == ds390_regWithIdx(R1_IDX) ))) -#define AOP_INDPTRn(x) (AOP_TYPE(x) == AOP_DPTRn) -#define AOP_USESDPTR(x) ((AOP_TYPE(x) == AOP_DPTR) || (AOP_TYPE(x) == AOP_STR)) -#define AOP_USESDPTR2(x) ((AOP_TYPE(x) == AOP_DPTR2) || (AOP_TYPE(x) == AOP_DPTRn)) - -// The following two macros can be used even if the aop has not yet been aopOp'd. -#define AOP_IS_STR(x) (IS_SYMOP(x) && OP_SYMBOL(x)->ruonly) -#define AOP_IS_DPTRn(x) (IS_SYMOP(x) && OP_SYMBOL(x)->dptr) - -/* Workaround for DS80C390 bug: div ab may return bogus results - * if A is accessed in instruction immediately before the div. - * - * Will be fixed in B4 rev of processor, Dallas claims. - */ - -#define LOAD_AB_FOR_DIV(LEFT, RIGHT, L) \ - if (!AOP_NEEDSACC(RIGHT)) \ - { \ - /* We can load A first, then B, since \ - * B (the RIGHT operand) won't clobber A, \ - * thus avoiding touching A right before the div. \ - */ \ - D(emitcode(";", "DS80C390 div bug: rearranged ops.");); \ - L = aopGet(AOP(LEFT),0,FALSE,FALSE,NULL); \ - MOVA(L); \ - L = aopGet(AOP(RIGHT),0,FALSE,FALSE,"b"); \ - MOVB(L); \ - } \ - else \ - { \ - /* Just stuff in a nop after loading A. */ \ - emitcode("mov","b,%s",aopGet(AOP(RIGHT),0,FALSE,FALSE,NULL));\ - L = aopGet(AOP(LEFT),0,FALSE,FALSE,NULL); \ - MOVA(L); \ - emitcode("nop", "; workaround for DS80C390 div bug."); \ - } - - /*-----------------------------------------------------------------*/ /* opIsGptr: returns non-zero if the passed operand is */ /* a generic pointer type. */ @@ -1771,13 +2005,13 @@ outAcc (operand * result) size = getDataSize (result); if (size) { - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); size--; offset = 1; /* unsigned or positive */ while (size--) { - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); } } } @@ -1791,7 +2025,7 @@ outBitC (operand * result) /* if the result is bit */ if (AOP_TYPE (result) == AOP_CRY) { - aopPut (AOP (result), "c", 0); + aopPut (result, "c", 0); } else { @@ -1807,9 +2041,9 @@ outBitC (operand * result) static void toBoolean (operand * oper) { - int size = AOP_SIZE (oper) - 1; - int offset = 1; - bool usedB = FALSE; + int size = AOP_SIZE (oper) - 1; + int offset = 1; + bool pushedB; /* The generic part of a generic pointer should * not participate in it's truth value. @@ -1818,49 +2052,34 @@ toBoolean (operand * oper) */ if (opIsGptr (oper)) { - D (emitcode (";", "toBoolean: generic ptr special case.");); + D (emitcode (";", "toBoolean: generic ptr special case.")); size--; } _startLazyDPSEvaluation (); - if (AOP_NEEDSACC (oper) && size) + MOVA (aopGet (oper, 0, FALSE, FALSE, NULL)); + if (AOP_NEEDSACC (oper) && size && (AOP (oper)->type != AOP_ACC)) { - usedB = TRUE; - if (_G.bInUse) - { - emitcode ("push", "b"); - } - MOVB (aopGet (AOP (oper), 0, FALSE, FALSE, NULL)); + pushedB = pushB (); + emitcode("mov", "b,a"); + while (--size) + { + MOVA (aopGet (oper, offset++, FALSE, FALSE, NULL)); + emitcode ("orl", "b,a"); + } + MOVA (aopGet (oper, offset++, FALSE, FALSE, NULL)); + emitcode ("orl", "a,b"); + popB (pushedB); } else { - MOVA (aopGet (AOP (oper), 0, FALSE, FALSE, NULL)); - } - - while (size--) - { - if (usedB) - { - emitcode ("orl", "b,%s", - aopGet (AOP (oper), offset++, FALSE, FALSE, NULL)); - } - else + while (size--) { emitcode ("orl", "a,%s", - aopGet (AOP (oper), offset++, FALSE, FALSE, NULL)); + aopGet (oper, offset++, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); - - if (usedB) - { - emitcode ("mov", "a,b"); - if (_G.bInUse) - { - emitcode ("pop", "b"); - } - - } } @@ -1872,7 +2091,7 @@ genNot (iCode * ic) { symbol *tlbl; - D (emitcode (";", "genNot ");); + D (emitcode (";", "genNot ")); /* assign asmOps to operand & result */ aopOp (IC_LEFT (ic), ic, FALSE, FALSE); @@ -1881,14 +2100,23 @@ genNot (iCode * ic) /* if in bit space then a special case */ if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) { - emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir); - emitcode ("cpl", "c"); - outBitC (IC_RESULT (ic)); + /* if left==result then cpl bit */ + if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic)))) + { + emitcode ("cpl", "%s", IC_LEFT (ic)->aop->aopu.aop_dir); + } + else + { + emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir); + emitcode ("cpl", "c"); + outBitC (IC_RESULT (ic)); + } goto release; } toBoolean (IC_LEFT (ic)); + /* set C, if a == 0 */ tlbl = newiTempLabel (NULL); emitcode ("cjne", "a,#1,!tlabel", tlbl->key + 100); emitcode ("", "!tlabeldef", tlbl->key + 100); @@ -1896,8 +2124,8 @@ genNot (iCode * ic) release: /* release the aops */ - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); } @@ -1933,9 +2161,10 @@ genCpl (iCode * ic) emitcode ("setb", "%s", IC_RESULT (ic)->aop->aopu.aop_dir); goto release; } + tlbl=newiTempLabel(NULL); - l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, FALSE, NULL); - if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC || + l = aopGet (IC_LEFT (ic), offset++, FALSE, FALSE, NULL); + if ((AOP_TYPE (IC_LEFT (ic)) == AOP_ACC && offset == 0) || AOP_TYPE (IC_LEFT (ic)) == AOP_REG || IS_AOP_PREG (IC_LEFT (ic))) { @@ -1946,7 +2175,7 @@ genCpl (iCode * ic) MOVA (l); emitcode ("cjne", "a,#0xFF,%05d$", tlbl->key + 100); } - emitcode ("", "%05d$:", tlbl->key+100); + emitcode ("", "%05d$:", tlbl->key + 100); outBitC (IC_RESULT(ic)); goto release; } @@ -1955,17 +2184,18 @@ genCpl (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL)); + char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("cpl", "a"); - aopPut (AOP (IC_RESULT (ic)), "a", offset++); + aopPut (IC_RESULT (ic), "a", offset++); } _endLazyDPSEvaluation (); release: /* release the aops */ - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); } /*-----------------------------------------------------------------*/ @@ -1975,8 +2205,9 @@ static void genUminusFloat (operand * op, operand * result) { int size, offset = 0; + char *l; - D(emitcode (";", "genUminusFloat");); + D(emitcode (";", "genUminusFloat")); /* for this we just copy and then flip the bit */ @@ -1985,16 +2216,17 @@ genUminusFloat (operand * op, operand * result) while (size--) { - aopPut (AOP (result), - aopGet (AOP (op), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (op, offset, FALSE, FALSE, NULL), offset); offset++; } - MOVA(aopGet (AOP (op), offset, FALSE, FALSE, NULL)); + l = aopGet (op, offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("cpl", "acc.7"); - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); _endLazyDPSEvaluation (); } @@ -2007,7 +2239,7 @@ genUminus (iCode * ic) int offset, size; sym_link *optype; - D (emitcode (";", "genUminus ");); + D (emitcode (";", "genUminus ")); /* assign asmops */ aopOp (IC_LEFT (ic), ic, FALSE, FALSE); @@ -2040,7 +2272,7 @@ genUminus (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL); + char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL); if (!strcmp (l, "a")) { if (offset == 0) @@ -2055,24 +2287,24 @@ genUminus (iCode * ic) emitcode ("clr", "a"); emitcode ("subb", "a,%s", l); } - aopPut (AOP (IC_RESULT (ic)), "a", offset++); + aopPut (IC_RESULT (ic), "a", offset++); } _endLazyDPSEvaluation (); /* if any remaining bytes in the result */ /* we just need to propagate the sign */ - if ((size = (AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_LEFT(ic)))) != 0) + if ((size = (AOP_SIZE (IC_RESULT (ic)) - AOP_SIZE (IC_LEFT (ic)))) != 0) { emitcode ("rlc", "a"); emitcode ("subb", "a,acc"); while (size--) - aopPut (AOP (IC_RESULT (ic)), "a", offset++); + aopPut (IC_RESULT (ic), "a", offset++); } release: /* release the aops */ - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); } /*-----------------------------------------------------------------*/ @@ -2080,28 +2312,37 @@ release: /*-----------------------------------------------------------------*/ static void savermask(bitVect *rs_mask) { - int i; - if (options.useXstack) { - if (bitVectBitValue (rs_mask, R0_IDX)) - emitcode ("mov", "b,r0"); - emitcode ("mov", "r0,%s", spname); - for (i = 0; i < ds390_nRegs; i++) { - if (bitVectBitValue (rs_mask, i)) { - if (i == R0_IDX) - emitcode ("mov", "a,b"); - else - emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name); - emitcode ("movx", "@r0,a"); - emitcode ("inc", "r0"); + int i; + if (options.useXstack) + { + if (bitVectBitValue (rs_mask, R0_IDX)) + emitcode ("mov", "b,r0"); + emitcode ("mov", "r0,%s", spname); + for (i = 0; i < ds390_nRegs; i++) + { + if (bitVectBitValue (rs_mask, i)) + { + if (i == R0_IDX) + emitcode ("mov", "a,b"); + else + emitcode ("mov", "a,%s", REG_WITH_INDEX (i)->name); + emitcode ("movx", "@r0,a"); + emitcode ("inc", "r0"); } } - emitcode ("mov", "%s,r0", spname); - if (bitVectBitValue (rs_mask, R0_IDX)) - emitcode ("mov", "r0,b"); - } else { - for (i = 0; i < ds390_nRegs; i++) { - if (bitVectBitValue (rs_mask, i)) - emitcode ("push", "%s", ds390_regWithIdx (i)->dname); + emitcode ("mov", "%s,r0", spname); + if (bitVectBitValue (rs_mask, R0_IDX)) + emitcode ("mov", "r0,b"); + } + else + { + bool bits_pushed = FALSE; + for (i = 0; i < ds390_nRegs; i++) + { + if (bitVectBitValue (rs_mask, i)) + { + bits_pushed = pushReg (i, bits_pushed); + } } } } @@ -2126,7 +2367,7 @@ saveRegisters (iCode * lic) return; } - /* if the registers have been saved already then + /* if the registers have been saved already or don't need to be then do nothing */ if (ic->regsSaved || (IS_SYMOP(IC_LEFT(ic)) && IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic))) && !TARGET_IS_DS400) ) @@ -2135,7 +2376,8 @@ saveRegisters (iCode * lic) /* special case if DPTR alive across a function call then must save it even though callee saves */ if (IS_SYMOP(IC_LEFT(ic)) && - IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) { + IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) + { int i; rsave = newBitVect(ic->rMask->size); for (i = DPL_IDX ; i <= B_IDX ; i++ ) { @@ -2143,12 +2385,14 @@ saveRegisters (iCode * lic) rsave = bitVectSetBit(rsave,i); } rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic))); - } else { - /* safe the registers in use at this time but skip the - ones for the result */ - rsave = bitVectCplAnd (bitVectCopy (ic->rMask), - ds390_rUmaskForOp (IC_RESULT(ic))); - } + } + else + { + /* save the registers in use at this time but skip the + ones for the result */ + rsave = bitVectCplAnd (bitVectCopy (ic->rMask), + ds390_rUmaskForOp (IC_RESULT(ic))); + } ic->regsSaved = 1; savermask(rsave); } @@ -2161,23 +2405,38 @@ static void unsavermask(bitVect *rs_mask) int i; if (options.useXstack) { emitcode ("mov", "r0,%s", spname); - for (i = ds390_nRegs; i >= 0; i--) { - if (bitVectBitValue (rs_mask, i)) { - emitcode ("dec", "r0"); - emitcode ("movx", "a,@r0"); - if (i == R0_IDX) - emitcode ("mov", "b,a"); - else - emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name); + for (i = ds390_nRegs; i >= 0; i--) + { + if (bitVectBitValue (rs_mask, i)) + { + regs * reg = REG_WITH_INDEX (i); + emitcode ("dec", "r0"); + emitcode ("movx", "a,@r0"); + if (i == R0_IDX) + { + emitcode ("push", "acc"); + } + else + { + emitcode ("mov", "%s,a", reg->name); + } } } - emitcode ("mov", "%s,r0", spname); - if (bitVectBitValue (rs_mask, R0_IDX)) - emitcode ("mov", "r0,b"); - } else { - for (i = ds390_nRegs; i >= 0; i--) { + emitcode ("mov", "%s,r0", spname); + if (bitVectBitValue (rs_mask, R0_IDX)) + { + emitcode ("pop", "ar0"); + } + } + else + { + bool bits_popped = FALSE; + for (i = ds390_nRegs; i >= 0; i--) + { if (bitVectBitValue (rs_mask, i)) - emitcode ("pop", "%s", ds390_regWithIdx (i)->dname); + { + bits_popped = popReg (i, bits_popped); + } } } } @@ -2219,59 +2478,68 @@ pushSide (operand * oper, int size) _startLazyDPSEvaluation (); while (size--) { - char *l = aopGet (AOP (oper), offset++, FALSE, TRUE, NULL); + char *l = aopGet (oper, offset++, FALSE, TRUE, NULL); if (AOP_TYPE (oper) != AOP_REG && AOP_TYPE (oper) != AOP_DIR && strcmp (l, "a")) { - emitcode ("mov", "a,%s", l); + MOVA (l); emitcode ("push", "acc"); } else + { emitcode ("push", "%s", l); } + } _endLazyDPSEvaluation (); } /*-----------------------------------------------------------------*/ -/* assignResultValue - */ +/* assignResultValue - also indicates if acc is in use afterwards */ /*-----------------------------------------------------------------*/ -static void -assignResultValue (operand * oper) +static bool +assignResultValue (operand * oper, operand * func) { int offset = 0; - int size = AOP_SIZE (oper); - bool pushedAcc = FALSE; + unsigned size = AOP_SIZE (oper); + bool accuse = FALSE; + bool pushedA = FALSE; + + if (func && IS_BIT (OP_SYM_ETYPE (func))) + { + outBitC (oper); + return FALSE; + } if (size == fReturnSizeDS390) { /* I don't think this case can ever happen... */ /* ACC is the last part of this. If writing the result - * uses AC, we must preserve it. + * uses ACC, we must preserve it. */ if (AOP_NEEDSACC(oper)) { emitcode(";", "assignResultValue special case for ACC."); emitcode("push", "acc"); - pushedAcc = TRUE; + pushedA = TRUE; size--; } } - _startLazyDPSEvaluation (); while (size--) { - aopPut (AOP (oper), fReturn[offset], offset); + accuse |= aopPut (oper, fReturn[offset], offset); offset++; } _endLazyDPSEvaluation (); - if (pushedAcc) + if (pushedA) { - emitcode("pop", "acc"); - aopPut(AOP(oper), "a", offset); + emitcode ("pop", "acc"); + accuse |= aopPut (oper, "a", offset); } + return accuse; } @@ -2285,30 +2553,37 @@ genXpush (iCode * ic) regs *r; int size, offset = 0; - D (emitcode (";", "genXpush "); - ); + D (emitcode (";", "genXpush ")); aopOp (IC_LEFT (ic), ic, FALSE, FALSE); r = getFreePtr (ic, &aop, FALSE); + size = AOP_SIZE (IC_LEFT (ic)); - emitcode ("mov", "%s,_spx", r->name); - - size = AOP_SIZE (IC_LEFT (ic)); - _startLazyDPSEvaluation (); - while (size--) - { - - MOVA (aopGet (AOP (IC_LEFT (ic)), - offset++, FALSE, FALSE, NULL)); + if (size == 1) + { + MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "%s,_spx", r->name); + emitcode ("inc", "_spx"); // allocate space first emitcode ("movx", "@%s,a", r->name); - emitcode ("inc", "%s", r->name); - } - _endLazyDPSEvaluation (); - + else + { + // allocate space first + emitcode ("mov", "%s,_spx", r->name); + MOVA (r->name); + emitcode ("add", "a,#%d", size); + emitcode ("mov", "_spx,a"); - emitcode ("mov", "_spx,%s", r->name); + _startLazyDPSEvaluation (); + while (size--) + { + MOVA (aopGet (IC_LEFT (ic), offset++, FALSE, FALSE, NULL)); + emitcode ("movx", "@%s,a", r->name); + emitcode ("inc", "%s", r->name); + } + _endLazyDPSEvaluation (); + } freeAsmop (NULL, aop, ic, TRUE); freeAsmop (IC_LEFT (ic), NULL, ic, TRUE); @@ -2322,9 +2597,9 @@ genIpush (iCode * ic) { int size, offset = 0; char *l; + char *prev = ""; - D (emitcode (";", "genIpush "); - ); + D (emitcode (";", "genIpush ")); /* if this is not a parm push : ie. it is spill push and spill push is always done on the local stack */ @@ -2341,7 +2616,7 @@ genIpush (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, NULL); + l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE, NULL); if (*l == '#') { MOVA (l); @@ -2353,7 +2628,7 @@ genIpush (iCode * ic) return; } - /* this is a paramter push: in this case we call + /* this is a parameter push: in this case we call the routine to find the call and save those registers that need to be saved */ saveRegisters (ic); @@ -2375,18 +2650,20 @@ genIpush (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, NULL); + l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE, NULL); if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG && AOP_TYPE (IC_LEFT (ic)) != AOP_DIR && strcmp (l, "acc")) { - emitcode ("mov", "a,%s", l); + if (strcmp (l, prev) || *l == '@') + MOVA (l); emitcode ("push", "acc"); } else { emitcode ("push", "%s", l); } + prev = l; } _endLazyDPSEvaluation (); @@ -2401,9 +2678,7 @@ genIpop (iCode * ic) { int size, offset; - D (emitcode (";", "genIpop "); - ); - + D (emitcode (";", "genIpop ")); /* if the temp was not pushed then */ if (OP_SYMBOL (IC_LEFT (ic))->isspilt || OP_SYMBOL (IC_LEFT (ic))->dptr) @@ -2415,7 +2690,7 @@ genIpop (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--, + emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--, FALSE, TRUE, NULL)); } _endLazyDPSEvaluation (); @@ -2424,12 +2699,13 @@ genIpop (iCode * ic) } /*-----------------------------------------------------------------*/ -/* unsaveRBank - restores the resgister bank from stack */ +/* saveRBank - saves an entire register bank on the stack */ /*-----------------------------------------------------------------*/ static void -unsaveRBank (int bank, iCode * ic, bool popPsw) +saveRBank (int bank, iCode * ic, bool pushPsw) { int i; + int count = 8 + (ds390_nBitRegs/8) + (pushPsw ? 1 : 0); asmop *aop = NULL; regs *r = NULL; @@ -2438,61 +2714,82 @@ unsaveRBank (int bank, iCode * ic, bool popPsw) if (!ic) { /* Assume r0 is available for use. */ - r = ds390_regWithIdx (R0_IDX);; + r = REG_WITH_INDEX (R0_IDX);; } else { aop = newAsmop (0); r = getFreePtr (ic, &aop, FALSE); } + // allocate space first emitcode ("mov", "%s,_spx", r->name); + MOVA (r->name); + emitcode ("add", "a,#%d", count); + emitcode ("mov", "_spx,a"); } - if (popPsw) + for (i = 0; i < 8; i++) /* only R0-R7 needs saving */ { if (options.useXstack) { - emitcode ("movx", "a,@%s", r->name); - emitcode ("mov", "psw,a"); - emitcode ("dec", "%s", r->name); + emitcode ("mov", "a,(%s+%d)", + regs390[i].base, 8 * bank + regs390[i].offset); + emitcode ("movx", "@%s,a", r->name); + if (--count) + emitcode ("inc", "%s", r->name); } else - { - emitcode ("pop", "psw"); - } + emitcode ("push", "(%s+%d)", + regs390[i].base, 8 * bank + regs390[i].offset); } - for (i = 7; i >= 0; i--) /* only R7-R0 needs to be popped */ + if (ds390_nBitRegs > 0) { if (options.useXstack) { - emitcode ("movx", "a,@%s", r->name); - emitcode ("mov", "(%s+%d),a", - regs390[i].base, 8 * bank + regs390[i].offset); - emitcode ("dec", "%s", r->name); - + emitcode ("mov", "a,bits"); + emitcode ("movx", "@%s,a", r->name); + if (--count) + emitcode ("inc", "%s", r->name); } else - emitcode ("pop", "(%s+%d)", - regs390[i].base, 8 * bank + regs390[i].offset); + { + emitcode ("push", "bits"); + } + BitBankUsed = 1; } - if (options.useXstack) + if (pushPsw) { - emitcode ("mov", "_spx,%s", r->name); + if (options.useXstack) + { + emitcode ("mov", "a,psw"); + emitcode ("movx", "@%s,a", r->name); + } + else + { + emitcode ("push", "psw"); + } + + emitcode ("mov", "psw,#!constbyte", (bank << 3) & 0x00ff); } if (aop) { freeAsmop (NULL, aop, ic, TRUE); } + + if (ic) + { + ic->bankSaved = 1; + } } /*-----------------------------------------------------------------*/ -/* saveRBank - saves an entire register bank on the stack */ +/* unsaveRBank - restores the register bank from stack */ /*-----------------------------------------------------------------*/ static void -saveRBank (int bank, iCode * ic, bool pushPsw) +unsaveRBank (int bank, iCode * ic, bool popPsw) { int i; asmop *aop = NULL; @@ -2503,7 +2800,7 @@ saveRBank (int bank, iCode * ic, bool pushPsw) if (!ic) { /* Assume r0 is available for use. */ - r = ds390_regWithIdx (R0_IDX);; + r = REG_WITH_INDEX (R0_IDX);; } else { @@ -2513,46 +2810,59 @@ saveRBank (int bank, iCode * ic, bool pushPsw) emitcode ("mov", "%s,_spx", r->name); } - for (i = 0; i < 8 ; i++) /* only R0-R7 needs saving */ + if (popPsw) { if (options.useXstack) { - emitcode ("inc", "%s", r->name); - emitcode ("mov", "a,(%s+%d)", - regs390[i].base, 8 * bank + regs390[i].offset); - emitcode ("movx", "@%s,a", r->name); + emitcode ("dec", "%s", r->name); + emitcode ("movx", "a,@%s", r->name); + emitcode ("mov", "psw,a"); } else - emitcode ("push", "(%s+%d)", - regs390[i].base, 8 * bank + regs390[i].offset); + { + emitcode ("pop", "psw"); + } } - if (pushPsw) + if (ds390_nBitRegs > 0) { if (options.useXstack) { - emitcode ("mov", "a,psw"); - emitcode ("movx", "@%s,a", r->name); - emitcode ("inc", "%s", r->name); - emitcode ("mov", "_spx,%s", r->name); + emitcode ("dec", "%s", r->name); + emitcode ("movx", "a,@%s", r->name); + emitcode ("mov", "bits,a"); } else - { - emitcode ("push", "psw"); - } + { + emitcode ("pop", "bits"); + } + } - emitcode ("mov", "psw,#!constbyte", (bank << 3) & 0x00ff); + for (i = 7; i >= 0; i--) /* only R7-R0 needs to be popped */ + { + if (options.useXstack) + { + emitcode ("dec", "%s", r->name); + emitcode ("movx", "a,@%s", r->name); + emitcode ("mov", "(%s+%d),a", + regs390[i].base, 8 * bank + regs390[i].offset); + } + else + { + emitcode ("pop", "(%s+%d)", + regs390[i].base, 8 * bank + regs390[i].offset); + } + } + + if (options.useXstack) + { + emitcode ("mov", "_spx,%s", r->name); } if (aop) { freeAsmop (NULL, aop, ic, TRUE); } - - if (ic) - { - ic->bankSaved = 1; - } } /*-----------------------------------------------------------------*/ @@ -2561,11 +2871,64 @@ saveRBank (int bank, iCode * ic, bool pushPsw) static void genSend(set *sendSet) { iCode *sic; + int bit_count = 0; int sendCount = 0 ; static int rb1_count = 0; + /* first we do all bit parameters */ for (sic = setFirstItem (sendSet); sic; - sic = setNextItem (sendSet)) { + sic = setNextItem (sendSet)) + { + if (sic->argreg > 12) + { + int bit = sic->argreg-13; + + aopOp (IC_LEFT (sic), sic, FALSE, + (AOP_IS_STR(IC_LEFT(sic)) ? FALSE : TRUE)); + + /* if left is a literal then + we know what the value is */ + if (AOP_TYPE (IC_LEFT (sic)) == AOP_LIT) + { + if (((int) operandLitValue (IC_LEFT (sic)))) + emitcode ("setb", "b[%d]", bit); + else + emitcode ("clr", "b[%d]", bit); + } + else if (AOP_TYPE (IC_LEFT (sic)) == AOP_CRY) + { + char *l = AOP (IC_LEFT (sic))->aopu.aop_dir; + if (strcmp (l, "c")) + emitcode ("mov", "c,%s", l); + emitcode ("mov", "b[%d],c", bit); + } + else + { + /* we need to or */ + toBoolean (IC_LEFT (sic)); + /* set C, if a >= 1 */ + emitcode ("add", "a,#0xff"); + emitcode ("mov", "b[%d],c", bit); + } + bit_count++; + BitBankUsed = 1; + + freeAsmop (IC_LEFT (sic), NULL, sic, TRUE); + } + } + + if (bit_count) + { + saveRegisters (setFirstItem (sendSet)); + emitcode ("mov", "bits,b"); + } + + /* then we do all other parameters */ + for (sic = setFirstItem (sendSet); sic; + sic = setNextItem (sendSet)) + { + if (sic->argreg <= 12) + { int size, offset = 0; size=getSize(operandType(IC_LEFT(sic))); @@ -2580,13 +2943,12 @@ static void genSend(set *sendSet) } else { aopOp (IC_LEFT (sic), sic, FALSE, FALSE); } - while (size--) { - char *l = aopGet (AOP (IC_LEFT (sic)), offset, - FALSE, FALSE, NULL); - if (strcmp (l, fReturn[offset])) { - emitcode ("mov", "%s,%s", - fReturn[offset], - l); + while (size--) + { + char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE, NULL); + if (strcmp (l, fReturn[offset])) + { + emitcode ("mov", "%s,%s", fReturn[offset], l); } offset++; } @@ -2596,12 +2958,13 @@ static void genSend(set *sendSet) } else { /* if more parameter in registers */ aopOp (IC_LEFT (sic), sic, FALSE, TRUE); while (size--) { - emitcode ("mov","b1_%d,%s",rb1_count++,aopGet (AOP (IC_LEFT (sic)), offset++, + emitcode ("mov","b1_%d,%s",rb1_count++,aopGet (IC_LEFT (sic), offset++, FALSE, FALSE, NULL)); } freeAsmop (IC_LEFT (sic), NULL, sic, TRUE); } sendCount++; + } } } @@ -2617,6 +2980,25 @@ adjustEsp(const char *reg) } } +/*-----------------------------------------------------------------*/ +/* selectRegBank - emit code to select the register bank */ +/*-----------------------------------------------------------------*/ +static void +selectRegBank (short bank, bool keepFlags) +{ + /* if f.e. result is in carry */ + if (keepFlags) + { + emitcode ("anl", "psw,#0xE7"); + if (bank) + emitcode ("orl", "psw,#0x%02x", (bank << 3) & 0xff); + } + else + { + emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0xff); + } +} + /*-----------------------------------------------------------------*/ /* genCall - generates a call statement */ /*-----------------------------------------------------------------*/ @@ -2624,15 +3006,21 @@ static void genCall (iCode * ic) { sym_link *dtype; + sym_link *etype; bool restoreBank = FALSE; bool swapBanks = FALSE; + bool accuse = FALSE; + bool accPushed = FALSE; + bool resultInF0 = FALSE; + bool assignResultGenerated = FALSE; - D (emitcode (";", "genCall ");); + D (emitcode (";", "genCall ")); /* if we are calling a not _naked function that is not using the same register bank then we need to save the destination registers on the stack */ dtype = operandType (IC_LEFT (ic)); + etype = getSpec(dtype); if (currFunc && dtype && (!IFFUNC_ISNAKED(dtype) || TARGET_IS_DS400) && (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) && IFFUNC_ISISR (currFunc->type)) @@ -2680,13 +3068,13 @@ genCall (iCode * ic) OP_SYMBOL (IC_LEFT (ic))->name)); if (swapBanks) - { - emitcode ("mov", "psw,#!constbyte", - ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff); - } + { + selectRegBank (FUNC_REGBANK(currFunc->type), IS_BIT (etype)); + } /* if we need assign a result value */ if ((IS_ITEMP (IC_RESULT (ic)) && + !IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && (OP_SYMBOL (IC_RESULT (ic))->nRegs || OP_SYMBOL (IC_RESULT (ic))->accuse || OP_SYMBOL (IC_RESULT (ic))->spildir)) || @@ -2696,45 +3084,46 @@ genCall (iCode * ic) && getSize (operandType (IC_RESULT (ic))) <= 2) { int size = getSize (operandType (IC_RESULT (ic))); + bool pushedB = FALSE; /* Special case for 1 or 2 byte return in far space. */ MOVA (fReturn[0]); if (size > 1) { + pushedB = pushB (); emitcode ("mov", "b,%s", fReturn[1]); - _G.bInUse++; } _G.accInUse++; aopOp (IC_RESULT (ic), ic, FALSE, FALSE); _G.accInUse--; - if (size > 1) - _G.bInUse--; + popB (pushedB); - aopPut (AOP (IC_RESULT (ic)), "a", 0); + aopPut (IC_RESULT (ic), "a", 0); if (size > 1) { - aopPut (AOP (IC_RESULT (ic)), "b", 1); + aopPut (IC_RESULT (ic), "b", 1); } + assignResultGenerated = TRUE; freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); } else { - _G.bInUse++; + bool pushedB = pushB (); aopOp (IC_RESULT (ic), ic, FALSE, TRUE); - _G.bInUse--; - - assignResultValue (IC_RESULT (ic)); + popB (pushedB); + accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic)); + assignResultGenerated = TRUE; freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); } } - /* adjust the stack for parameters if - required */ - if (ic->parmBytes) { + /* adjust the stack for parameters if required */ + if (ic->parmBytes) + { int i; if (options.stack10bit) { if (ic->parmBytes <= 10) { @@ -2755,23 +3144,66 @@ genCall (iCode * ic) UNPROTECT_SP; } } else { - if (ic->parmBytes > 3) { + if (ic->parmBytes > 3) + { + if (accuse) + { + emitcode ("push", "acc"); + accPushed = TRUE; + } + if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) && + IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && + !assignResultGenerated) + { + emitcode ("mov", "F0,c"); + resultInF0 = TRUE; + } emitcode ("mov", "a,%s", spname); emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff); emitcode ("mov", "%s,a", spname); - } else + + /* unsaveRegisters from xstack needs acc, but */ + /* unsaveRegisters from stack needs this popped */ + if (accPushed && !options.useXstack) + { + emitcode ("pop", "acc"); + accPushed = FALSE; + } + } + else for (i = 0; i < ic->parmBytes; i++) emitcode ("dec", "%s", spname); } } - /* if we hade saved some registers then unsave them */ - if (ic->regsSaved) - unsaveRegisters (ic); + /* if we had saved some registers then unsave them */ + if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype)) + { + if (accuse && !accPushed && options.useXstack) + { + /* xstack needs acc, but doesn't touch normal stack */ + emitcode ("push", "acc"); + accPushed = TRUE; + } + unsaveRegisters (ic); + } /* if register bank was saved then pop them */ if (restoreBank) unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE); + + if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && !assignResultGenerated) + { + if (resultInF0) + emitcode ("mov", "c,F0"); + + aopOp (IC_RESULT (ic), ic, FALSE, FALSE); + assignResultValue (IC_RESULT (ic), IC_LEFT (ic)); + freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + } + + if (accPushed) + emitcode ("pop", "acc"); } /*-----------------------------------------------------------------*/ @@ -2781,21 +3213,22 @@ static void genPcall (iCode * ic) { sym_link *dtype; + sym_link *etype; symbol *rlbl = newiTempLabel (NULL); bool restoreBank=FALSE; + bool resultInF0 = FALSE; - D (emitcode (";", "genPcall "); - ); - + D (emitcode (";", "genPcall ")); + dtype = operandType (IC_LEFT (ic))->next; + etype = getSpec(dtype); /* if caller saves & we have not saved then */ if (!ic->regsSaved) saveRegisters (ic); - /* if we are calling a function that is not using + /* if we are calling a not _naked function that is not using the same register bank then we need to save the destination registers on the stack */ - dtype = operandType (IC_LEFT (ic)); if (currFunc && dtype && (!IFFUNC_ISNAKED(dtype) || TARGET_IS_DS400) && IFFUNC_ISISR (currFunc->type) && (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype))) { @@ -2835,6 +3268,7 @@ genPcall (iCode * ic) /* if we need assign a result value */ if ((IS_ITEMP (IC_RESULT (ic)) && + !IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && (OP_SYMBOL (IC_RESULT (ic))->nRegs || OP_SYMBOL (IC_RESULT (ic))->spildir)) || IS_TRUE_SYMOP (IC_RESULT (ic))) @@ -2844,13 +3278,12 @@ genPcall (iCode * ic) aopOp (IC_RESULT (ic), ic, FALSE, TRUE); _G.accInUse--; - assignResultValue (IC_RESULT (ic)); + assignResultValue (IC_RESULT (ic), IC_LEFT (ic)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); } - /* adjust the stack for parameters if - required */ + /* adjust the stack for parameters if required */ if (ic->parmBytes) { int i; @@ -2861,6 +3294,13 @@ genPcall (iCode * ic) emitcode("pop","acc"); } } else { + if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) && + IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic)))) + { + emitcode ("mov", "F0,c"); + resultInF0 = TRUE; + } + PROTECT_SP; emitcode ("clr","c"); emitcode ("mov","a,sp"); @@ -2874,25 +3314,39 @@ genPcall (iCode * ic) } } else { if (ic->parmBytes > 3) { + if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) && + IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic)))) + { + emitcode ("mov", "F0,c"); + resultInF0 = TRUE; + } + emitcode ("mov", "a,%s", spname); emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff); emitcode ("mov", "%s,a", spname); - } + } else for (i = 0; i < ic->parmBytes; i++) emitcode ("dec", "%s", spname); - } } /* if register bank was saved then unsave them */ if (restoreBank) unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE); - /* if we hade saved some registers then - unsave them */ + /* if we had saved some registers then unsave them */ if (ic->regsSaved) unsaveRegisters (ic); + if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic)))) + { + if (resultInF0) + emitcode ("mov", "c,F0"); + + aopOp (IC_RESULT (ic), ic, FALSE, FALSE); + assignResultValue (IC_RESULT (ic), IC_LEFT (ic)); + freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + } } /*-----------------------------------------------------------------*/ @@ -2947,20 +3401,22 @@ inExcludeList (char *s) static void genFunction (iCode * ic) { - symbol *sym; + symbol *sym = OP_SYMBOL (IC_LEFT (ic)); sym_link *ftype; bool switchedPSW = FALSE; + bool fReentrant = (IFFUNC_ISREENT (sym->type) || options.stackAuto); - D (emitcode (";", "genFunction ");); + D (emitcode (";", "genFunction ")); _G.nRegsSaved = 0; /* create the function header */ emitcode (";", "-----------------------------------------"); - emitcode (";", " function %s", (sym = OP_SYMBOL (IC_LEFT (ic)))->name); + emitcode (";", " function %s", sym->name); emitcode (";", "-----------------------------------------"); emitcode ("", "%s:", sym->rname); ftype = operandType (IC_LEFT (ic)); + _G.currentFunc = sym; if (IFFUNC_ISNAKED(ftype)) { @@ -3033,22 +3489,22 @@ genFunction (iCode * ic) save only those registers that are used */ if (!IFFUNC_HASFCALL(sym->type)) { - /* if any registers used */ if (sym->regsUsed) { + bool bits_pushed = FALSE; /* save the registers used */ for (i = 0; i < sym->regsUsed->size; i++) { if (bitVectBitValue (sym->regsUsed, i)) - emitcode ("push", "%s", ds390_regWithIdx (i)->dname); + bits_pushed = pushReg (i, bits_pushed); } } } else { - /* this function has a function call cannot - determines register usage so we will have to push the + /* this function has a function call. We cannot + determine register usage so we will have to push the entire bank */ saveRBank (0, ic, FALSE); if (options.parms_in_bank1) { @@ -3160,12 +3616,13 @@ genFunction (iCode * ic) /* if any registers used */ if (sym->regsUsed) { + bool bits_pushed = FALSE; /* save the registers used */ for (i = 0; i < sym->regsUsed->size; i++) { if (bitVectBitValue (sym->regsUsed, i)) { - emitcode ("push", "%s", ds390_regWithIdx (i)->dname); + bits_pushed = pushReg (i, bits_pushed); _G.nRegsSaved++; } } @@ -3181,7 +3638,7 @@ genFunction (iCode * ic) emitcode ("mov", "psw,#!constbyte", (FUNC_REGBANK (sym->type) << 3) & 0x00ff); } - if ( (IFFUNC_ISREENT (sym->type) || options.stackAuto) && + if (fReentrant && (sym->stack || FUNC_HASSTACKPARM(sym->type))) { if (options.stack10bit) { emitcode ("push","_bpx"); @@ -3190,7 +3647,8 @@ genFunction (iCode * ic) emitcode ("mov","_bpx+1,esp"); adjustEsp("_bpx+1"); } else { - if (options.useXstack) { + if (options.useXstack) + { emitcode ("mov", "r0,%s", spname); emitcode ("mov", "a,_bp"); emitcode ("movx", "@r0,a"); @@ -3256,7 +3714,6 @@ genFunction (iCode * ic) emitcode ("", "%05d$:", (tlbl->key + 100)); emitcode ("push", "psw"); /* save old ea via c in psw */ } - } /*-----------------------------------------------------------------*/ @@ -3274,6 +3731,7 @@ genEndFunction (iCode * ic) D (emitcode (";", "genEndFunction ");); + _G.currentFunc = NULL; if (IFFUNC_ISNAKED(sym->type)) { emitcode(";", "naked function: no epilogue."); @@ -3284,8 +3742,18 @@ genEndFunction (iCode * ic) if (IFFUNC_ISCRITICAL (sym->type)) { - emitcode ("pop", "psw"); /* restore ea via c in psw */ - emitcode ("mov", "ea,c"); + if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic)))) + { + emitcode ("rlc", "a"); /* save c in a */ + emitcode ("pop", "psw"); /* restore ea via c in psw */ + emitcode ("mov", "ea,c"); + emitcode ("rrc", "a"); /* restore c from a */ + } + else + { + emitcode ("pop", "psw"); /* restore ea via c in psw */ + emitcode ("mov", "ea,c"); + } } if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) && @@ -3357,22 +3825,22 @@ genEndFunction (iCode * ic) save only those registers that are used */ if (!IFFUNC_HASFCALL(sym->type)) { - /* if any registers used */ if (sym->regsUsed) { + bool bits_popped = FALSE; /* save the registers used */ for (i = sym->regsUsed->size; i >= 0; i--) { if (bitVectBitValue (sym->regsUsed, i)) - emitcode ("pop", "%s", ds390_regWithIdx (i)->dname); + bits_popped = popReg (i, bits_popped); } } } else { - /* this function has a function call cannot - determines register usage so we will have to pop the + /* this function has a function call. We cannot + determine register usage so we will have to pop the entire bank */ if (options.parms_in_bank1) { for (i = 7 ; i >= 0 ; i-- ) { @@ -3431,7 +3899,8 @@ genEndFunction (iCode * ic) emitcode ("pop", "acc"); /* if debug then send end of function */ - if (options.debug && currFunc) { + if (options.debug && currFunc) + { debugFile->writeEndFunction (currFunc, ic, 1); } @@ -3450,7 +3919,7 @@ genEndFunction (iCode * ic) for (i = sym->regsUsed->size; i >= 0; i--) { if (bitVectBitValue (sym->regsUsed, i)) - emitcode ("pop", "%s", ds390_regWithIdx (i)->dname); + emitcode ("pop", "%s", REG_WITH_INDEX (i)->dname); } } } @@ -3564,7 +4033,7 @@ genEndFunction (iCode * ic) for (idx = 0; idx < regsUnneeded->size; idx++) if (bitVectBitValue (regsUnneeded, idx)) - emitcode ("", ";\teliminated unneeded push/pop %s", ds390_regWithIdx (idx)->dname); + emitcode ("", ";\teliminated unneeded push/pop %s", REG_WITH_INDEX (idx)->dname); freeBitVect (regsUnneeded); freeBitVect (regsUsed); @@ -3589,7 +4058,7 @@ static void genJavaNativeRet(iCode *ic) aopHasRegs(AOP(IC_LEFT(ic)),R2_IDX,R3_IDX)) { for (i = 0 ; i < size ; i++ ) { emitcode ("push","%s", - aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(IC_LEFT(ic),i,FALSE,TRUE,DP2_RESULT_REG)); } for (i = (size-1) ; i >= 0 ; i--) { emitcode ("pop","a%s",javaRet[i]); @@ -3597,7 +4066,7 @@ static void genJavaNativeRet(iCode *ic) } else { for (i = 0 ; i < size ; i++) emitcode ("mov","%s,%s",javaRet[i], - aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(IC_LEFT(ic),i,FALSE,TRUE,DP2_RESULT_REG)); } for (i = size ; i < 4 ; i++ ) emitcode ("mov","%s,#0",javaRet[i]); @@ -3612,7 +4081,7 @@ genRet (iCode * ic) { int size, offset = 0, pushed = 0; - D (emitcode (";", "genRet ");); + D (emitcode (";", "genRet")); /* if we have no return value then just generate the "ret" */ @@ -3632,12 +4101,19 @@ genRet (iCode * ic) size = AOP_SIZE (IC_LEFT (ic)); _startLazyDPSEvaluation (); + + if (IS_BIT(_G.currentFunc->etype)) + { + movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE, NULL)); + size = 0; + } + while (size--) { char *l; if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR) { - l = aopGet (AOP (IC_LEFT (ic)), offset++, + l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE, NULL); emitcode ("push", "%s", l); pushed++; @@ -3645,9 +4121,9 @@ genRet (iCode * ic) else { /* Since A is the last element of fReturn, - * is is OK to clobber it in the aopGet. + * it is OK to clobber it in the aopGet. */ - l = aopGet (AOP (IC_LEFT (ic)), offset, + l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL); if (strcmp (fReturn[offset], l)) emitcode ("mov", "%s,%s", fReturn[offset++], l); @@ -3655,16 +4131,13 @@ genRet (iCode * ic) } _endLazyDPSEvaluation (); - if (pushed) + while (pushed) { - while (pushed) - { - pushed--; - if (strcmp (fReturn[pushed], "a")) - emitcode ("pop", fReturn[pushed]); - else - emitcode ("pop", "acc"); - } + pushed--; + if (strcmp (fReturn[pushed], "a")) + emitcode ("pop", fReturn[pushed]); + else + emitcode ("pop", "acc"); } freeAsmop (IC_LEFT (ic), NULL, ic, TRUE); @@ -3688,8 +4161,7 @@ genLabel (iCode * ic) if (IC_LABEL (ic) == entryLabel) return; - D (emitcode (";", "genLabel "); - ); + D (emitcode (";", "genLabel ")); emitcode ("", "!tlabeldef", (IC_LABEL (ic)->key + 100)); } @@ -3700,8 +4172,8 @@ genLabel (iCode * ic) static void genGoto (iCode * ic) { - D (emitcode (";", "genGoto "); - ); + D (emitcode (";", "genGoto ")); + emitcode ("ljmp", "!tlabel", (IC_LABEL (ic)->key + 100)); } @@ -3761,7 +4233,7 @@ genPlusIncr (iCode * ic) if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) && AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) { while (icount--) { - emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,NULL)); + emitcode("inc","%s",aopGet(IC_RESULT(ic),0,FALSE,FALSE,NULL)); } return TRUE; } @@ -3795,14 +4267,13 @@ genPlusIncr (iCode * ic) tlbl = newiTempLabel (NULL); emitTlbl = 1; } - - l = aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), LSB, FALSE, FALSE, NULL); emitcode ("inc", "%s", l); if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || IS_AOP_PREG (IC_RESULT (ic))) { - emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100); + emitcode ("cjne", "%s,%s,!tlabel", l, zero, tlbl->key + 100); } else { @@ -3810,7 +4281,7 @@ genPlusIncr (iCode * ic) emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100); } - l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE, NULL); emitcode ("inc", "%s", l); if (size > 2) { @@ -3821,14 +4292,14 @@ genPlusIncr (iCode * ic) else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || IS_AOP_PREG (IC_RESULT (ic))) { - emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100); + emitcode ("cjne", "%s,%s,!tlabel", l, zero, tlbl->key + 100); } else { emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100); } - l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE, NULL); emitcode ("inc", "%s", l); } if (size > 3) @@ -3840,14 +4311,14 @@ genPlusIncr (iCode * ic) else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || IS_AOP_PREG (IC_RESULT (ic))) { - emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100); + emitcode ("cjne", "%s,%s,!tlabel", l, zero, tlbl->key + 100); } else { emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100); } - l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE, NULL); emitcode ("inc", "%s", l); } @@ -3864,18 +4335,19 @@ genPlusIncr (iCode * ic) { if (IC_RESULT(ic)->isGptr) { - emitcode ("mov","b,%s",aopGet(AOP (IC_LEFT (ic)), 3, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet(IC_LEFT (ic), 3, FALSE, FALSE, NULL)); } switch (size) { case 3: - emitcode ("mov","dpx,%s",aopGet(AOP (IC_LEFT (ic)), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet(IC_LEFT (ic), 2, FALSE, FALSE, NULL)); case 2: - emitcode ("mov","dph,%s",aopGet(AOP (IC_LEFT (ic)), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet(IC_LEFT (ic), 1, FALSE, FALSE, NULL)); case 1: - emitcode ("mov","dpl,%s",aopGet(AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet(IC_LEFT (ic), 0, FALSE, FALSE, NULL)); break; } - while (icount--) emitcode ("inc","dptr"); + while (icount--) + emitcode ("inc", "dptr"); return TRUE; } @@ -3883,8 +4355,9 @@ genPlusIncr (iCode * ic) AOP(IC_LEFT(ic))->aopu.dptr == AOP(IC_RESULT(ic))->aopu.dptr && icount <= 5 ) { emitcode ("mov","dps,#!constbyte",AOP(IC_LEFT(ic))->aopu.dptr); - while (icount--) emitcode ("inc","dptr"); - emitcode ("mov","dps,#0"); + while (icount--) + emitcode ("inc", "dptr"); + emitcode ("mov", "dps,#0"); return TRUE; } @@ -3901,20 +4374,18 @@ genPlusIncr (iCode * ic) AOP_TYPE (IC_RESULT (ic)) == AOP_REG && sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic)))) { - if (icount > 3) { - MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE, NULL)); emitcode ("add", "a,#!constbyte", ((char) icount) & 0xff); - aopPut (AOP (IC_RESULT (ic)), "a", 0); + aopPut (IC_RESULT (ic), "a", 0); } else { - _startLazyDPSEvaluation (); while (icount--) { - emitcode ("inc", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL)); + emitcode ("inc", "%s", aopGet (IC_LEFT (ic), 0, FALSE, FALSE, NULL)); } _endLazyDPSEvaluation (); } @@ -3935,7 +4406,7 @@ outBitAcc (operand * result) /* if the result is a bit */ if (AOP_TYPE (result) == AOP_CRY) { - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); } else { @@ -3952,7 +4423,7 @@ outBitAcc (operand * result) static void genPlusBits (iCode * ic) { - D (emitcode (";", "genPlusBits ");); + D (emitcode (";", "genPlusBits ")); if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) { @@ -3969,7 +4440,7 @@ genPlusBits (iCode * ic) emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir); emitcode ("rlc", "a"); emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir); - emitcode ("addc", "a,#0"); + emitcode ("addc", "a,%s", zero); outAcc (IC_RESULT (ic)); } } @@ -3981,8 +4452,8 @@ adjustArithmeticResult (iCode * ic) opIsGptr (IC_LEFT (ic)) && !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) { - aopPut (AOP (IC_RESULT (ic)), - aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE, NULL), + aopPut (IC_RESULT (ic), + aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE, NULL), GPTRSIZE - 1); } @@ -3990,8 +4461,8 @@ adjustArithmeticResult (iCode * ic) opIsGptr (IC_RIGHT (ic)) && !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) { - aopPut (AOP (IC_RESULT (ic)), - aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE, NULL), + aopPut (IC_RESULT (ic), + aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE, NULL), GPTRSIZE - 1); } @@ -4001,10 +4472,10 @@ adjustArithmeticResult (iCode * ic) !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))) && !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) { - char buff[5]; - SNPRINTF (buff, sizeof(buff), + char buffer[5]; + SNPRINTF (buffer, sizeof(buffer), "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); - aopPut (AOP (IC_RESULT (ic)), buff, GPTRSIZE - 1); + aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1); } } @@ -4204,8 +4675,9 @@ genPlus (iCode * ic) int size, offset = 0; bool pushResult; int rSize; + bool swappedLR = FALSE; - D (emitcode (";", "genPlus ");); + D (emitcode (";", "genPlus ")); /* special cases :- */ if ( AOP_IS_STR(IC_LEFT(ic)) && @@ -4255,6 +4727,7 @@ genPlus (iCode * ic) operand *t = IC_RIGHT (ic); IC_RIGHT (ic) = IC_LEFT (ic); IC_LEFT (ic) = t; + swappedLR = TRUE; emitcode (";", "Swapped plus args."); } @@ -4285,9 +4758,9 @@ genPlus (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL)); - emitcode ("addc", "a,#0"); - aopPut (AOP (IC_RESULT (ic)), "a", offset++); + MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE, NULL)); + emitcode ("addc", "a,%s", zero); + aopPut (IC_RESULT (ic), "a", offset++); } _endLazyDPSEvaluation (); } @@ -4310,13 +4783,13 @@ genPlus (iCode * ic) { if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && !AOP_NEEDSACC(IC_RIGHT(ic))) { - MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL)); if (offset == 0) emitcode ("add", "a,%s", - aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL)); + aopGet (IC_RIGHT (ic), offset, FALSE, FALSE, NULL)); else emitcode ("addc", "a,%s", - aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL)); + aopGet (IC_RIGHT (ic), offset, FALSE, FALSE, NULL)); } else { @@ -4330,7 +4803,7 @@ genPlus (iCode * ic) D(emitcode(";", "+ AOP_ACC special case.");); emitcode("xch", "a, %s", DP2_RESULT_REG); } - MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE, NULL)); if (offset == 0) { if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) @@ -4341,20 +4814,20 @@ genPlus (iCode * ic) else { emitcode ("add", "a,%s", - aopGet (AOP(IC_LEFT(ic)), offset, FALSE, FALSE, + aopGet (IC_LEFT(ic), offset, FALSE, FALSE, DP2_RESULT_REG)); } } else { emitcode ("addc", "a,%s", - aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, + aopGet (IC_LEFT (ic), offset, FALSE, FALSE, DP2_RESULT_REG)); } } if (!pushResult) { - aopPut (AOP (IC_RESULT (ic)), "a", offset); + aopPut (IC_RESULT (ic), "a", offset); } else { @@ -4377,7 +4850,7 @@ genPlus (iCode * ic) while (size--) { emitcode ("pop", "acc"); - aopPut (AOP (IC_RESULT (ic)), "a", size); + aopPut (IC_RESULT (ic), "a", size); } _endLazyDPSEvaluation (); } @@ -4385,13 +4858,21 @@ genPlus (iCode * ic) adjustArithmeticResult (ic); release: - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + if (!swappedLR) + { + freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + } + else + { + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + } } /*-----------------------------------------------------------------*/ -/* genMinusDec :- does subtraction with deccrement if possible */ +/* genMinusDec :- does subtraction with decrement if possible */ /*-----------------------------------------------------------------*/ static bool genMinusDec (iCode * ic) @@ -4413,7 +4894,7 @@ genMinusDec (iCode * ic) if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) && AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) { while (icount--) { - emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,NULL)); + emitcode("dec","%s",aopGet(IC_RESULT(ic),0,FALSE,FALSE,NULL)); } return TRUE; } @@ -4447,7 +4928,7 @@ genMinusDec (iCode * ic) emitTlbl = 1; } - l = aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), LSB, FALSE, FALSE, NULL); emitcode ("dec", "%s", l); if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || @@ -4461,7 +4942,7 @@ genMinusDec (iCode * ic) emitcode ("mov", "a,#!constbyte",0xff); emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100); } - l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE, NULL); emitcode ("dec", "%s", l); if (size > 2) { @@ -4480,7 +4961,7 @@ genMinusDec (iCode * ic) emitcode ("mov", "a,#!constbyte",0xff); emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100); } - l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE, NULL); emitcode ("dec", "%s", l); } if (size > 3) @@ -4500,7 +4981,7 @@ genMinusDec (iCode * ic) emitcode ("mov", "a,#!constbyte",0xff); emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100); } - l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL); + l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE, NULL); emitcode ("dec", "%s", l); } if (emitTlbl) @@ -4523,15 +5004,28 @@ genMinusDec (iCode * ic) AOP_TYPE (IC_RESULT (ic)) == AOP_REG && sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic)))) { + char *l; + + if (aopGetUsesAcc (IC_LEFT (ic), 0)) + { + MOVA (aopGet (IC_RESULT (ic), 0, FALSE, FALSE, NULL)); + l = "a"; + } + else + { + l = aopGet (IC_RESULT (ic), 0, FALSE, FALSE, NULL); + } _startLazyDPSEvaluation (); while (icount--) { - emitcode ("dec", "%s", - aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL)); + emitcode ("dec", "%s", l); } _endLazyDPSEvaluation (); + if (AOP_NEEDSACC (IC_RESULT (ic))) + aopPut (IC_RESULT (ic), "a", 0); + return TRUE; } @@ -4554,14 +5048,14 @@ addSign (operand * result, int offset, int sign) emitcode ("subb", "a,acc"); while (size--) { - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } } else { while (size--) { - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); } } _endLazyDPSEvaluation(); @@ -4576,7 +5070,7 @@ genMinusBits (iCode * ic) { symbol *lbl = newiTempLabel (NULL); - D (emitcode (";", "genMinusBits ");); + D (emitcode (";", "genMinusBits ")); if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) { @@ -4593,7 +5087,7 @@ genMinusBits (iCode * ic) emitcode ("jnb", "%s,!tlabel", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100)); emitcode ("inc", "a"); emitcode ("", "!tlabeldef", (lbl->key + 100)); - aopPut (AOP (IC_RESULT (ic)), "a", 0); + aopPut (IC_RESULT (ic), "a", 0); addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic))))); } } @@ -4609,7 +5103,7 @@ genMinus (iCode * ic) long lit = 0L; bool pushResult; - D (emitcode (";", "genMinus ");); + D (emitcode (";", "genMinus ")); AOP_OP_3_NOFATAL(ic, pushResult); @@ -4650,17 +5144,17 @@ genMinus (iCode * ic) if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT) { if (AOP_USESDPTR(IC_RIGHT(ic))) { emitcode ("mov","b,%s", - aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL)); - MOVA(aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL)); + aopGet (IC_RIGHT (ic), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL)); emitcode ("subb","a,b"); } else { - MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL)); emitcode ("subb", "a,%s", - aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, + aopGet (IC_RIGHT (ic), offset, FALSE, FALSE, DP2_RESULT_REG)); } } else { - MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE, NULL)); /* first add without previous c */ if (!offset) { if (!size && lit==-1) { @@ -4678,7 +5172,7 @@ genMinus (iCode * ic) if (pushResult) { emitcode ("push", "acc"); } else { - aopPut (AOP (IC_RESULT (ic)), "a", offset); + aopPut (IC_RESULT (ic), "a", offset); } offset++; } @@ -4697,7 +5191,7 @@ genMinus (iCode * ic) while (size--) { emitcode ("pop", "acc"); - aopPut (AOP (IC_RESULT (ic)), "a", size); + aopPut (IC_RESULT (ic), "a", size); } _endLazyDPSEvaluation (); } @@ -4705,9 +5199,9 @@ genMinus (iCode * ic) adjustArithmeticResult (ic); release: - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } @@ -4720,13 +5214,14 @@ genMultbits (operand * left, operand * result, iCode * ic) { + D(emitcode (";", "genMultbits")); + emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir); emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir); aopOp(result, ic, TRUE, FALSE); outBitC (result); } - /*-----------------------------------------------------------------*/ /* genMultOneByte : 8*8=8/16 bit multiplication */ /*-----------------------------------------------------------------*/ @@ -4736,21 +5231,10 @@ genMultOneByte (operand * left, operand * result, iCode * ic) { - int size; symbol *lbl; + int size; bool runtimeSign, compiletimeSign; - bool lUnsigned, rUnsigned; - - - /* (if two literals: the value is computed before) */ - /* if one literal, literal on the right */ - if (AOP_TYPE (left) == AOP_LIT) - { - operand *t = right; - right = left; - left = t; - emitcode (";", "swapped left and right"); - } + bool lUnsigned, rUnsigned, pushedB; /* (if two literals: the value is computed before) */ /* if one literal, literal on the right */ @@ -4773,6 +5257,8 @@ genMultOneByte (operand * left, lUnsigned = SPEC_USIGN (getSpec (operandType (left))); rUnsigned = SPEC_USIGN (getSpec (operandType (right))); + pushedB = pushB (); + if ((lUnsigned && rUnsigned) /* sorry, I don't know how to get size without calling aopOp (result,...); @@ -4783,11 +5269,11 @@ genMultOneByte (operand * left, /* just an unsigned 8 * 8 = 8 multiply or 8u * 8u = 16u */ /* emitcode (";","unsigned"); */ - emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL)); - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE, NULL)); + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); emitcode ("mul", "ab"); - _G.accInUse++; _G.bInUse++; + _G.accInUse++; aopOp (result, ic, TRUE, FALSE); size = AOP_SIZE (result); @@ -4799,10 +5285,12 @@ genMultOneByte (operand * left, exit (1); } - aopPut (AOP (result), "a", 0); - _G.accInUse--; _G.bInUse--; + aopPut (result, "a", 0); + _G.accInUse--; if (size == 2) - aopPut (AOP (result), "b", 1); + aopPut (result, "b", 1); + + popB (pushedB); return; } @@ -4867,10 +5355,10 @@ genMultOneByte (operand * left, else /* ! literal */ { if (rUnsigned) /* emitcode (";", "signed"); */ - emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE, NULL)); else { - MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); lbl = newiTempLabel (NULL); emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100); emitcode ("cpl", "F0"); /* complement sign flag */ @@ -4892,12 +5380,10 @@ genMultOneByte (operand * left, } else /* ! literal */ { - if (lUnsigned) /* emitcode (";", "signed"); */ + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); - emitcode ("mov", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL)); - else + if (!lUnsigned) /* emitcode (";", "signed"); */ { - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); lbl = newiTempLabel (NULL); emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100); emitcode ("cpl", "F0"); /* complement sign flag */ @@ -4909,7 +5395,7 @@ genMultOneByte (operand * left, /* now the multiplication */ emitcode ("mul", "ab"); - _G.accInUse++;_G.bInUse++; + _G.accInUse++; aopOp(result, ic, TRUE, FALSE); size = AOP_SIZE (result); @@ -4939,10 +5425,12 @@ genMultOneByte (operand * left, } emitcode ("", "!tlabeldef", lbl->key + 100); } - aopPut (AOP (result), "a", 0); - _G.accInUse--;_G.bInUse--; + aopPut (result, "a", 0); + _G.accInUse--; if (size == 2) - aopPut (AOP (result), "b", 1); + aopPut (result, "b", 1); + + popB (pushedB); } /*-----------------------------------------------------------------*/ @@ -4981,8 +5469,8 @@ static void genMultTwoByte (operand *left, operand *right, emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff); } else { lbl = newiTempLabel(NULL); - emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL)); - emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL)); + emitcode ("mov","b,%s",aopGet(right,0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(right,1,FALSE,FALSE,NULL)); emitcode ("jnb","acc.7,!tlabel",lbl->key+100); emitcode ("xch", "a,b"); emitcode ("cpl","a"); @@ -4996,14 +5484,14 @@ static void genMultTwoByte (operand *left, operand *right, emitcode ("mov","mb,a"); } } else { - emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL)); - emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL)); + emitcode ("mov","mb,%s",aopGet(right,0,FALSE,FALSE,NULL)); + emitcode ("mov","mb,%s",aopGet(right,1,FALSE,FALSE,NULL)); } /* load up MA with left */ if (!umult) { lbl = newiTempLabel(NULL); - emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov","b,%s",aopGet(left,0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(left,1,FALSE,FALSE,NULL)); emitcode ("jnb","acc.7,!tlabel",lbl->key+100); emitcode ("xch", "a,b"); emitcode ("cpl","a"); @@ -5017,8 +5505,8 @@ static void genMultTwoByte (operand *left, operand *right, emitcode ("mov","ma,b"); emitcode ("mov","ma,a"); } else { - emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov","ma,%s",aopGet(left,0,FALSE,FALSE,NULL)); + emitcode ("mov","ma,%s",aopGet(left,1,FALSE,FALSE,NULL)); } /* wait for multiplication to finish */ lbl = newiTempLabel(NULL); @@ -5034,11 +5522,11 @@ static void genMultTwoByte (operand *left, operand *right, /* if unsigned then simple */ if (umult) { emitcode ("mov","a,ma"); - if (AOP_SIZE(result) >= 4) aopPut(AOP(result),"a",3); + if (AOP_SIZE(result) >= 4) aopPut(result,"a",3); emitcode ("mov","a,ma"); - if (AOP_SIZE(result) >= 3) aopPut(AOP(result),"a",2); - aopPut(AOP(result),"ma",1); - aopPut(AOP(result),"ma",0); + if (AOP_SIZE(result) >= 3) aopPut(result,"a",2); + aopPut(result,"ma",1); + aopPut(result,"ma",0); } else { emitcode("push","ma"); emitcode("push","ma"); @@ -5060,7 +5548,7 @@ static void genMultTwoByte (operand *left, operand *right, } else { - aopPut(AOP(result),"a",0); + aopPut(result,"a",0); } emitcode("pop","acc"); @@ -5069,7 +5557,7 @@ static void genMultTwoByte (operand *left, operand *right, emitcode("cpl","a"); emitcode("addc","a,#0"); emitcode("","!tlabeldef", lbl->key+100); - aopPut(AOP(result),"a",1); + aopPut(result,"a",1); emitcode("pop","acc"); if (AOP_SIZE(result) >= 3) { lbl = newiTempLabel(NULL); @@ -5077,7 +5565,7 @@ static void genMultTwoByte (operand *left, operand *right, emitcode("cpl","a"); emitcode("addc","a,#0"); emitcode("","!tlabeldef", lbl->key+100); - aopPut(AOP(result),"a",2); + aopPut(result,"a",2); } emitcode("pop","acc"); if (AOP_SIZE(result) >= 4) { @@ -5086,7 +5574,7 @@ static void genMultTwoByte (operand *left, operand *right, emitcode("cpl","a"); emitcode("addc","a,#0"); emitcode("","!tlabeldef", lbl->key+100); - aopPut(AOP(result),"a",3); + aopPut(result,"a",3); } if (AOP_TYPE(result) == AOP_ACC) { @@ -5115,9 +5603,9 @@ genMult (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D (emitcode (";", "genMult ");); + D (emitcode (";", "genMult ")); - /* assign the amsops */ + /* assign the asmops */ AOP_OP_2 (ic); /* special cases first */ @@ -5146,9 +5634,9 @@ genMult (iCode * ic) assert (0); release: - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } /*-----------------------------------------------------------------*/ @@ -5160,8 +5648,12 @@ genDivbits (operand * left, operand * result, iCode * ic) { - char *l; + bool pushedB; + + D(emitcode ("; genDivbits","")); + + pushedB = pushB (); /* the result must be bit */ LOAD_AB_FOR_DIV (left, right, l); @@ -5169,7 +5661,9 @@ genDivbits (operand * left, emitcode ("rrc", "a"); aopOp(result, ic, TRUE, FALSE); - aopPut (AOP (result), "c", 0); + popB (pushedB); + + aopPut (result, "c", 0); } /*-----------------------------------------------------------------*/ @@ -5181,16 +5675,20 @@ genDivOneByte (operand * left, operand * result, iCode * ic) { - bool lUnsigned, rUnsigned; + bool lUnsigned, rUnsigned, pushedB; bool runtimeSign, compiletimeSign; char *l; symbol *lbl; int size, offset; + D(emitcode ("; genDivOneByte","")); + offset = 1; lUnsigned = SPEC_USIGN (getSpec (operandType (left))); rUnsigned = SPEC_USIGN (getSpec (operandType (right))); + pushedB = pushB (); + /* signed or unsigned */ if (lUnsigned && rUnsigned) { @@ -5200,13 +5698,15 @@ genDivOneByte (operand * left, _G.accInUse++; aopOp (result, ic, TRUE, FALSE); - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); _G.accInUse--; size = AOP_SIZE (result) - 1; while (size--) - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); + + popB (pushedB); return; } @@ -5270,10 +5770,10 @@ genDivOneByte (operand * left, else /* ! literal */ { if (rUnsigned) - emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE, NULL)); else { - MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); lbl = newiTempLabel (NULL); emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100); emitcode ("cpl", "F0"); /* complement sign flag */ @@ -5295,11 +5795,10 @@ genDivOneByte (operand * left, } else /* ! literal */ { - if (lUnsigned) - emitcode ("mov", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL)); - else + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); + + if (!lUnsigned) { - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); lbl = newiTempLabel (NULL); emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100); emitcode ("cpl", "F0"); /* complement sign flag */ @@ -5322,7 +5821,7 @@ genDivOneByte (operand * left, emitcode ("inc", "a"); emitcode ("", "!tlabeldef", lbl->key + 100); - _G.accInUse++; _G.bInUse++; + _G.accInUse++; aopOp (result, ic, TRUE, FALSE); size = AOP_SIZE (result) - 1; @@ -5338,26 +5837,26 @@ genDivOneByte (operand * left, emitcode ("subb", "a,acc"); emitcode ("xch", "a,b"); /* 2 */ while (size--) - aopPut (AOP (result), "b", offset++); /* write msb's */ + aopPut (result, "b", offset++); /* write msb's */ } else /* compiletimeSign */ while (size--) - aopPut (AOP (result), "#0xff", offset++); /* write msb's */ + aopPut (result, "#0xff", offset++); /* write msb's */ } - aopPut (AOP (result), "a", 0); /* 3: write lsb */ + aopPut (result, "a", 0); /* 3: write lsb */ } else { - _G.accInUse++; _G.bInUse++; + _G.accInUse++; aopOp(result, ic, TRUE, FALSE); size = AOP_SIZE (result) - 1; - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); while (size--) - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); } - _G.accInUse--; _G.bInUse--; - + _G.accInUse--; + popB (pushedB); } /*-----------------------------------------------------------------*/ @@ -5382,8 +5881,8 @@ static void genDivTwoByte (operand *left, operand *right, if (!umult) { emitcode("clr","F0"); lbl = newiTempLabel(NULL); - emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov","b,%s",aopGet(left,0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(left,1,FALSE,FALSE,NULL)); emitcode ("jnb","acc.7,!tlabel",lbl->key+100); emitcode ("xch", "a,b"); emitcode ("cpl","a"); @@ -5396,8 +5895,8 @@ static void genDivTwoByte (operand *left, operand *right, emitcode ("mov","ma,b"); emitcode ("mov","ma,a"); } else { - emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov","ma,%s",aopGet(left,0,FALSE,FALSE,NULL)); + emitcode ("mov","ma,%s",aopGet(left,1,FALSE,FALSE,NULL)); } /* load up MB with right */ @@ -5415,8 +5914,8 @@ static void genDivTwoByte (operand *left, operand *right, emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff); } else { lbl = newiTempLabel(NULL); - emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL)); - emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL)); + emitcode ("mov","b,%s",aopGet(right,0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(right,1,FALSE,FALSE,NULL)); emitcode ("jnb","acc.7,!tlabel",lbl->key+100); emitcode ("xch", "a,b"); emitcode ("cpl","a"); @@ -5431,8 +5930,8 @@ static void genDivTwoByte (operand *left, operand *right, emitcode ("mov","mb,a"); } } else { - emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL)); - emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL)); + emitcode ("mov","mb,%s",aopGet(right,0,FALSE,FALSE,NULL)); + emitcode ("mov","mb,%s",aopGet(right,1,FALSE,FALSE,NULL)); } /* wait for multiplication to finish */ @@ -5448,8 +5947,8 @@ static void genDivTwoByte (operand *left, operand *right, /* if unsigned then simple */ if (umult) { - aopPut(AOP(result),"ma",1); - aopPut(AOP(result),"ma",0); + aopPut(result,"ma",1); + aopPut(result,"ma",0); } else { emitcode("push","ma"); MOVA("ma"); @@ -5459,14 +5958,14 @@ static void genDivTwoByte (operand *left, operand *right, emitcode("cpl","a"); emitcode("add","a,#1"); emitcode("","!tlabeldef", lbl->key+100); - aopPut(AOP(result),"a",0); + aopPut(result,"a",0); emitcode("pop","acc"); lbl = newiTempLabel(NULL); emitcode("jnb","F0,!tlabel",lbl->key+100); emitcode("cpl","a"); emitcode("addc","a,#0"); emitcode("","!tlabeldef", lbl->key+100); - aopPut(AOP(result),"a",1); + aopPut(result,"a",1); } freeAsmop (result, NULL, ic, TRUE); /* restore EA bit in F1 */ @@ -5487,7 +5986,7 @@ genDiv (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D (emitcode (";", "genDiv ");); + D (emitcode (";", "genDiv ")); /* assign the amsops */ AOP_OP_2 (ic); @@ -5517,9 +6016,9 @@ genDiv (iCode * ic) /* should have been converted to function call */ assert (0); release: - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } /*-----------------------------------------------------------------*/ @@ -5531,8 +6030,12 @@ genModbits (operand * left, operand * result, iCode * ic) { - char *l; + bool pushedB; + + D(emitcode ("; genModbits","")); + + pushedB = pushB (); /* the result must be bit */ LOAD_AB_FOR_DIV (left, right, l); @@ -5540,7 +6043,10 @@ genModbits (operand * left, emitcode ("mov", "a,b"); emitcode ("rrc", "a"); aopOp(result, ic, TRUE, FALSE); - aopPut (AOP (result), "c", 0); + + popB (pushedB); + + aopPut (result, "c", 0); } /*-----------------------------------------------------------------*/ @@ -5552,16 +6058,20 @@ genModOneByte (operand * left, operand * result, iCode * ic) { - bool lUnsigned, rUnsigned; + bool lUnsigned, rUnsigned, pushedB; bool runtimeSign, compiletimeSign; char *l; symbol *lbl; int size, offset; + D(emitcode ("; genModOneByte","")); + offset = 1; lUnsigned = SPEC_USIGN (getSpec (operandType (left))); rUnsigned = SPEC_USIGN (getSpec (operandType (right))); + pushedB = pushB (); + /* signed or unsigned */ if (lUnsigned && rUnsigned) { @@ -5569,10 +6079,12 @@ genModOneByte (operand * left, LOAD_AB_FOR_DIV (left, right, l); emitcode ("div", "ab"); aopOp (result, ic, TRUE, FALSE); - aopPut (AOP (result), "b", 0); + aopPut (result, "b", 0); for (size = AOP_SIZE (result) - 1; size--;) - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); + + popB (pushedB); return; } @@ -5590,13 +6102,13 @@ genModOneByte (operand * left, else emitcode ("mov", "b,#0x%02x", (unsigned char) val); } - else /* ! literal */ + else /* not literal */ { if (rUnsigned) - emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE, NULL)); else { - MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); lbl = newiTempLabel (NULL); emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100); emitcode ("cpl", "a"); /* 2's complement */ @@ -5627,7 +6139,7 @@ genModOneByte (operand * left, } else /* ! literal */ { - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); if (!lUnsigned) { @@ -5657,7 +6169,7 @@ genModOneByte (operand * left, emitcode ("inc", "a"); emitcode ("", "!tlabeldef", lbl->key + 100); - _G.accInUse++; _G.bInUse++; + _G.accInUse++; aopOp (result, ic, TRUE, FALSE); size = AOP_SIZE (result) - 1; @@ -5673,26 +6185,26 @@ genModOneByte (operand * left, emitcode ("subb", "a,acc"); emitcode ("xch", "a,b"); /* 2 */ while (size--) - aopPut (AOP (result), "b", offset++); /* write msb's */ + aopPut (result, "b", offset++); /* write msb's */ } else /* compiletimeSign */ while (size--) - aopPut (AOP (result), "#0xff", offset++); /* write msb's */ + aopPut (result, "#0xff", offset++); /* write msb's */ } - aopPut (AOP (result), "a", 0); /* 3: write lsb */ + aopPut (result, "a", 0); /* 3: write lsb */ } else { - _G.accInUse++; _G.bInUse++; + _G.accInUse++; aopOp(result, ic, TRUE, FALSE); size = AOP_SIZE (result) - 1; - aopPut (AOP (result), "b", 0); + aopPut (result, "b", 0); while (size--) - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); } - _G.accInUse--; _G.bInUse--; - + _G.accInUse--; + popB (pushedB); } /*-----------------------------------------------------------------*/ @@ -5716,8 +6228,8 @@ static void genModTwoByte (operand *left, operand *right, if (!umult) { lbl = newiTempLabel(NULL); - emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov","b,%s",aopGet(left,0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(left,1,FALSE,FALSE,NULL)); emitcode ("jnb","acc.7,!tlabel",lbl->key+100); emitcode ("xch", "a,b"); emitcode ("cpl","a"); @@ -5729,8 +6241,8 @@ static void genModTwoByte (operand *left, operand *right, emitcode ("mov","ma,b"); emitcode ("mov","ma,a"); } else { - emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov","ma,%s",aopGet(left,0,FALSE,FALSE,NULL)); + emitcode ("mov","ma,%s",aopGet(left,1,FALSE,FALSE,NULL)); } /* load up MB with right */ @@ -5744,8 +6256,8 @@ static void genModTwoByte (operand *left, operand *right, emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff); } else { lbl = newiTempLabel(NULL); - emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL)); - emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL)); + emitcode ("mov","b,%s",aopGet(right,0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(right,1,FALSE,FALSE,NULL)); emitcode ("jnb","acc.7,!tlabel",lbl->key+100); emitcode ("xch", "a,b"); emitcode ("cpl","a"); @@ -5758,8 +6270,8 @@ static void genModTwoByte (operand *left, operand *right, emitcode ("mov","mb,a"); } } else { - emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL)); - emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL)); + emitcode ("mov","mb,%s",aopGet(right,0,FALSE,FALSE,NULL)); + emitcode ("mov","mb,%s",aopGet(right,1,FALSE,FALSE,NULL)); } /* wait for multiplication to finish */ @@ -5773,8 +6285,8 @@ static void genModTwoByte (operand *left, operand *right, freeAsmop (right, NULL, ic,TRUE); aopOp(result, ic, TRUE, FALSE); - aopPut(AOP(result),"mb",1); - aopPut(AOP(result),"mb",0); + aopPut(result,"mb",1); + aopPut(result,"mb",0); freeAsmop (result, NULL, ic, TRUE); /* restore EA bit in F1 */ @@ -5795,9 +6307,9 @@ genMod (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D (emitcode (";", "genMod "); ); + D (emitcode (";", "genMod ")); - /* assign the amsops */ + /* assign the asmops */ AOP_OP_2 (ic); /* special cases first */ @@ -5827,9 +6339,9 @@ genMod (iCode * ic) assert (0); release: - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } /*-----------------------------------------------------------------*/ @@ -5842,7 +6354,7 @@ genIfxJump (iCode * ic, char *jval) symbol *tlbl = newiTempLabel (NULL); char *inst; - D (emitcode (";", "genIfxJump");); + D (emitcode (";", "genIfxJump")); /* if true label then we jump if condition supplied is true */ @@ -5881,7 +6393,7 @@ genCmp (operand * left, operand * right, unsigned long lit = 0L; operand *result; - D (emitcode (";", "genCmp");); + D (emitcode (";", "genCmp")); result = IC_RESULT (ic); @@ -5900,13 +6412,13 @@ genCmp (operand * left, operand * right, size = max (AOP_SIZE (left), AOP_SIZE (right)); /* if unsigned char cmp with lit, do cjne left,#right,zz */ - if ((size == 1) && !sign - && (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR && AOP_TYPE (left) != AOP_STR)) + if ((size == 1) && !sign && + (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR && AOP_TYPE (left) != AOP_STR)) { symbol *lbl = newiTempLabel (NULL); emitcode ("cjne", "%s,%s,!tlabel", - aopGet (AOP (left), offset, FALSE, FALSE, NULL), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopGet (left, offset, FALSE, FALSE, NULL), + aopGet (right, offset, FALSE, FALSE, NULL), lbl->key + 100); emitcode ("", "!tlabeldef", lbl->key + 100); } @@ -5924,7 +6436,7 @@ genCmp (operand * left, operand * right, } else { - MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE, NULL)); + MOVA (aopGet (left, AOP_SIZE (left) - 1, FALSE, FALSE, NULL)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); @@ -5950,7 +6462,7 @@ genCmp (operand * left, operand * right, while (size--) { // emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset); - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); // emitcode (";", "genCmp #2"); if (sign && (size == 0)) { @@ -5968,7 +6480,7 @@ genCmp (operand * left, operand * right, { // emitcode (";", "genCmp #3.2"); saveAccWarn = 0; - MOVB(aopGet (AOP (right), offset++, FALSE, FALSE, "b")); + MOVB (aopGet (right, offset++, FALSE, FALSE, "b")); saveAccWarn = DEFAULT_ACC_WARNING; emitcode ("xrl", "b,#!constbyte",0x80); emitcode ("subb", "a,b"); @@ -5980,7 +6492,7 @@ genCmp (operand * left, operand * right, // emitcode (";", "genCmp #4"); saveAccWarn = 0; - s = aopGet (AOP (right), offset++, FALSE, FALSE, "b"); + s = aopGet (right, offset++, FALSE, FALSE, "b"); saveAccWarn = DEFAULT_ACC_WARNING; emitcode ("subb", "a,%s", s); @@ -5991,8 +6503,8 @@ genCmp (operand * left, operand * right, release: /* Don't need the left & right operands any more; do need the result. */ - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); aopOp (result, ic, FALSE, FALSE); @@ -6030,8 +6542,7 @@ genCmpGt (iCode * ic, iCode * ifx) sym_link *letype, *retype; int sign; - D (emitcode (";", "genCmpGt "); - ); + D (emitcode (";", "genCmpGt")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -6056,7 +6567,7 @@ genCmpLt (iCode * ic, iCode * ifx) sym_link *letype, *retype; int sign; - D (emitcode (";", "genCmpLt ");); + D (emitcode (";", "genCmpLt ")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -6081,8 +6592,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl) int offset = 0; unsigned long lit = 0L; - D (emitcode (";", "gencjneshort"); - ); + D (emitcode (";", "gencjneshort")); /* if the left side is a literal or if the right is in a pointer register and left @@ -6115,9 +6625,9 @@ gencjneshort (operand * left, operand * right, symbol * lbl) { while (size--) { - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("cjne", "a,%s,!tlabel", - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopGet (right, offset, FALSE, FALSE, NULL), lbl->key + 100); offset++; } @@ -6134,13 +6644,13 @@ gencjneshort (operand * left, operand * right, symbol * lbl) { while (size--) { - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) && ((unsigned int) ((lit >> (offset * 8)) & 0x0FFL) == 0)) emitcode ("jnz", "!tlabel", lbl->key + 100); else emitcode ("cjne", "a,%s,!tlabel", - aopGet (AOP (right), offset, FALSE, TRUE, DP2_RESULT_REG), + aopGet (right, offset, FALSE, TRUE, DP2_RESULT_REG), lbl->key + 100); offset++; } @@ -6150,8 +6660,8 @@ gencjneshort (operand * left, operand * right, symbol * lbl) /* right is a pointer reg need both a & b */ while (size--) { - MOVB (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVB (aopGet (left, offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); emitcode ("cjne", "a,b,!tlabel", lbl->key + 100); offset++; } @@ -6166,8 +6676,7 @@ gencjne (operand * left, operand * right, symbol * lbl) { symbol *tlbl = newiTempLabel (NULL); - D (emitcode (";", "gencjne"); - ); + D (emitcode (";", "gencjne")); gencjneshort (left, right, lbl); @@ -6186,8 +6695,7 @@ genCmpEq (iCode * ic, iCode * ifx) { operand *left, *right, *result; - D (emitcode (";", "genCmpEq "); - ); + D (emitcode (";", "genCmpEq")); AOP_OP_2 (ic); AOP_SET_LOCALS (ic); @@ -6341,7 +6849,7 @@ genCmpEq (iCode * ic, iCode * ifx) if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) { - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); goto release; } if (ifx) @@ -6381,6 +6889,7 @@ ifxForOp (operand * op, iCode * ic) return NULL; } + /*-----------------------------------------------------------------*/ /* hasInc - operand is incremented before any other use */ /*-----------------------------------------------------------------*/ @@ -6427,7 +6936,7 @@ genAndOp (iCode * ic) operand *left, *right, *result; symbol *tlbl; - D (emitcode (";", "genAndOp ");); + D (emitcode (";", "genAndOp ")); /* note here that && operations that are in an if statement are taken away by backPatchLabels @@ -6473,7 +6982,7 @@ genOrOp (iCode * ic) operand *left, *right, *result; symbol *tlbl; - D (emitcode (";", "genOrOp ");); + D (emitcode (";", "genOrOp ")); /* note here that || operations that are in an if statement are taken away by backPatchLabels @@ -6598,9 +7107,9 @@ genFarFarLogicOp(iCode *ic, char *logicOp) _startLazyDPSEvaluation(); for (size = compSize; (size--); offset++) { - MOVA (aopGet (AOP (IC_LEFT(ic)), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_LEFT(ic), offset, FALSE, FALSE, NULL)); emitcode ("mov", "%s, acc", DP2_RESULT_REG); - MOVA (aopGet (AOP (IC_RIGHT(ic)), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (IC_RIGHT(ic), offset, FALSE, FALSE, NULL)); emitcode (logicOp, "a,%s", DP2_RESULT_REG); emitcode ("push", "acc"); @@ -6619,7 +7128,7 @@ genFarFarLogicOp(iCode *ic, char *logicOp) while (compSize--) { emitcode ("pop", "acc"); - aopPut (AOP (IC_RESULT (ic)), "a", compSize); + aopPut (IC_RESULT (ic), "a", compSize); } _endLazyDPSEvaluation(); freeAsmop(IC_RESULT (ic), NULL, ic, TRUE); @@ -6635,11 +7144,11 @@ genAnd (iCode * ic, iCode * ifx) operand *left, *right, *result; int size, offset = 0; unsigned long lit = 0L; - int bytelit; - char buff[10]; + int bytelit = 0; + char buffer[10]; bool pushResult; - D (emitcode (";", "genAnd ");); + D (emitcode (";", "genAnd")); AOP_OP_3_NOFATAL (ic, pushResult); AOP_SET_LOCALS (ic); @@ -6733,7 +7242,7 @@ genAnd (iCode * ic, iCode * ifx) else { // c = bit & val; - MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); // c = lsb emitcode ("rrc", "a"); emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir); @@ -6760,18 +7269,28 @@ genAnd (iCode * ic, iCode * ifx) if (posbit) { posbit--; - MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE, NULL)); + MOVA (aopGet (left, posbit >> 3, FALSE, FALSE, NULL)); // bit = left & 2^n if (size) - emitcode ("mov", "c,acc.%d", posbit & 0x07); + { + switch (posbit & 0x07) + { + case 0: emitcode ("rrc", "a"); + break; + case 7: emitcode ("rlc", "a"); + break; + default: emitcode ("mov", "c,acc.%d", posbit & 0x07); + break; + } + } // if(left & 2^n) else { if (ifx) { - SNPRINTF (buff, sizeof(buff), + SNPRINTF (buffer, sizeof(buffer), "acc.%d", posbit & 0x07); - genIfxJump (ifx, buff); + genIfxJump (ifx, buffer); } else { @@ -6790,7 +7309,7 @@ genAnd (iCode * ic, iCode * ifx) { if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L) { - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); // byte == 2^n ? if ((posbit = isLiteralBit (bytelit)) != 0) emitcode ("jb", "acc.%d,!tlabel", (posbit - 1) & 0x07, tlbl->key + 100); @@ -6798,7 +7317,7 @@ genAnd (iCode * ic, iCode * ifx) { if (bytelit != 0x0FFL) emitcode ("anl", "a,%s", - aopGet (AOP (right), offset, FALSE, TRUE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, TRUE, DP2_RESULT_REG)); emitcode ("jnz", "!tlabel", tlbl->key + 100); } } @@ -6836,43 +7355,43 @@ genAnd (iCode * ic, iCode * ifx) { /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); else continue; } else if (bytelit == 0) { - aopPut (AOP (result), zero, offset); + aopPut (result, zero, offset); } else if (IS_AOP_PREG (result)) { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("anl", "a,%s", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); - aopPut (AOP (result), "a", offset); + aopGet (right, offset, FALSE, TRUE, DP2_RESULT_REG)); + aopPut (result, "a", offset); } else emitcode ("anl", "%s,%s", - aopGet (AOP (left), offset, FALSE, TRUE, NULL), - aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + aopGet (left, offset, FALSE, TRUE, NULL), + aopGet (right, offset, FALSE, FALSE, NULL)); } else { if (AOP_TYPE (left) == AOP_ACC) emitcode ("anl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); else { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); if (IS_AOP_PREG (result)) { emitcode ("anl", "a,%s", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); - aopPut (AOP (result), "a", offset); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); + aopPut (result, "a", offset); } else emitcode ("anl", "%s,a", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); } } } @@ -6893,16 +7412,21 @@ genAnd (iCode * ic, iCode * ifx) { if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) { emitcode ("anl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - if (AOP_TYPE(left)==AOP_ACC) { + if (AOP_TYPE(left)==AOP_ACC) + { + bool pushedB = pushB (); emitcode("mov", "b,a"); - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); emitcode("anl", "a,b"); - }else { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + popB (pushedB); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); emitcode ("anl", "a,%s", - aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, FALSE, DP2_RESULT_REG)); } } emitcode ("jnz", "!tlabel", tlbl->key + 100); @@ -6930,8 +7454,8 @@ genAnd (iCode * ic, iCode * ifx) bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL); if (bytelit == 0x0FF) { - aopPut (AOP (result), - aopGet (AOP (left), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (left, offset, FALSE, FALSE, NULL), offset); continue; } @@ -6939,13 +7463,13 @@ genAnd (iCode * ic, iCode * ifx) { /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); - aopPut (AOP (result), zero, offset); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); + aopPut (result, zero, offset); continue; } D (emitcode (";", "better literal AND.");); - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); - emitcode ("anl", "a, %s", aopGet (AOP (right), offset, + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); + emitcode ("anl", "a, %s", aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } @@ -6956,33 +7480,32 @@ genAnd (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_ACC) { emitcode ("anl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL); + char *rOp = aopGet (right, offset, FALSE, FALSE, NULL); if (!strcmp(rOp, "a") || !strcmp(rOp, "acc")) { emitcode("mov", "b,a"); rOp = "b"; } - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("anl", "a,%s", rOp); } } - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } } } release: - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } - /*-----------------------------------------------------------------*/ /* genOr - code for or */ /*-----------------------------------------------------------------*/ @@ -6995,7 +7518,7 @@ genOr (iCode * ic, iCode * ifx) int bytelit = 0; bool pushResult; - D (emitcode (";", "genOr ");); + D (emitcode (";", "genOr ")); AOP_OP_3_NOFATAL (ic, pushResult); AOP_SET_LOCALS (ic); @@ -7055,7 +7578,7 @@ genOr (iCode * ic, iCode * ifx) { if (AOP_TYPE (right) == AOP_LIT) { - // c = bit & literal; + // c = bit | literal; if (lit) { // lit != 0 => result = 1 @@ -7162,31 +7685,31 @@ genOr (iCode * ic, iCode * ifx) { if (AOP_TYPE (right) == AOP_LIT) { - bytelit = (int)((lit >> (offset * 8)) & 0x0FFL); - if (bytelit == 0x00L) + bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL); + if (bytelit == 0) { /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); else continue; } else if (bytelit == 0x0FF) { - aopPut (AOP (result), "#0xFF", offset); + aopPut (result, "#0xFF", offset); } else if (IS_AOP_PREG (left)) { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); emitcode ("orl", "a,%s", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); - aopPut (AOP (result), "a", offset); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); + aopPut (result, "a", offset); } else { emitcode ("orl", "%s,%s", - aopGet (AOP (left), offset, FALSE, TRUE, NULL), - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, TRUE, NULL), + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } } else @@ -7194,21 +7717,21 @@ genOr (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_ACC) { emitcode ("orl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); if (IS_AOP_PREG (left)) { emitcode ("orl", "a,%s", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); - aopPut (AOP (result), "a", offset); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); + aopPut (result, "a", offset); } else { emitcode ("orl", "%s,a", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); } } } @@ -7230,11 +7753,11 @@ genOr (iCode * ic, iCode * ifx) { if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) { emitcode ("orl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); emitcode ("orl", "a,%s", - aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, FALSE, DP2_RESULT_REG)); } emitcode ("jnz", "!tlabel", tlbl->key + 100); offset++; @@ -7256,14 +7779,14 @@ genOr (iCode * ic, iCode * ifx) for (; (size--); offset++) { // normal case - // result = left & right + // result = left | right if (AOP_TYPE (right) == AOP_LIT) { - bytelit = (int)((lit >> (offset * 8)) & 0x0FFL); - if (bytelit == 0x00L) + bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL); + if (bytelit == 0) { - aopPut (AOP (result), - aopGet (AOP (left), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (left, offset, FALSE, FALSE, NULL), offset); continue; } @@ -7271,14 +7794,14 @@ genOr (iCode * ic, iCode * ifx) { /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); - aopPut (AOP (result), "#0xFF", offset); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); + aopPut (result, "#0xFF", offset); continue; } D (emitcode (";", "better literal OR.");); - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("orl", "a, %s", - aopGet (AOP (right), offset, + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } @@ -7289,12 +7812,12 @@ genOr (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_ACC) { emitcode ("orl", "a,%s", - aopGet (AOP (right), offset, + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL); + char *rOp = aopGet (right, offset, FALSE, FALSE, NULL); if (!strcmp(rOp, "a") || !strcmp(rOp, "acc")) { @@ -7302,20 +7825,20 @@ genOr (iCode * ic, iCode * ifx) rOp = "b"; } - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("orl", "a,%s", rOp); } } - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } _endLazyDPSEvaluation(); } } release: - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } /*-----------------------------------------------------------------*/ @@ -7330,7 +7853,7 @@ genXor (iCode * ic, iCode * ifx) int bytelit = 0; bool pushResult; - D (emitcode (";", "genXor ");); + D (emitcode (";", "genXor ")); AOP_OP_3_NOFATAL (ic, pushResult); AOP_SET_LOCALS (ic); @@ -7448,7 +7971,7 @@ genXor (iCode * ic, iCode * ifx) emitcode ("setb", "c"); while (sizer) { - MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, NULL)); + MOVA (aopGet (right, sizer - 1, FALSE, FALSE, NULL)); if (sizer == 1) // test the msb of the lsb emitcode ("anl", "a,#!constbyte",0xfe); @@ -7480,45 +8003,45 @@ genXor (iCode * ic, iCode * ifx) if (AOP_TYPE (right) == AOP_LIT) { bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL); - if (bytelit == 0x00L) + if (bytelit == 0) { /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); else continue; } else if (IS_AOP_PREG (left)) { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("xrl", "a,%s", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); - aopPut (AOP (result), "a", offset); + aopGet (right, offset, FALSE, TRUE, DP2_RESULT_REG)); + aopPut (result, "a", offset); } else { emitcode ("xrl", "%s,%s", - aopGet (AOP (left), offset, FALSE, TRUE, NULL), - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, TRUE, NULL), + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } } else { if (AOP_TYPE (left) == AOP_ACC) emitcode ("xrl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); else { - MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset, FALSE, FALSE, NULL)); if (IS_AOP_PREG (left)) { emitcode ("xrl", "a,%s", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); - aopPut (AOP (result), "a", offset); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); + aopPut (result, "a", offset); } else emitcode ("xrl", "%s,a", - aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG)); + aopGet (left, offset, FALSE, TRUE, DP2_RESULT_REG)); } } } @@ -7541,22 +8064,22 @@ genXor (iCode * ic, iCode * ifx) if ((AOP_TYPE (right) == AOP_LIT) && (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)) { - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); } else { if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) { emitcode ("xrl", "a,%s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL); + char *rOp = aopGet (right, offset, FALSE, FALSE, NULL); if (!strcmp(rOp, "a") || !strcmp(rOp, "acc")) { emitcode("mov", "b,a"); rOp = "b"; } - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("xrl", "a,%s", rOp); } } @@ -7577,20 +8100,21 @@ genXor (iCode * ic, iCode * ifx) for (; (size--); offset++) { // normal case - // result = left & right + // result = left ^ right if (AOP_TYPE (right) == AOP_LIT) { - if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L) + bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL); + if (bytelit == 0) { - aopPut (AOP (result), - aopGet (AOP (left), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (left, offset, FALSE, FALSE, NULL), offset); continue; } D (emitcode (";", "better literal XOR.");); - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("xrl", "a, %s", - aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { @@ -7599,32 +8123,31 @@ genXor (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_ACC) { emitcode ("xrl", "a,%s", - aopGet (AOP (right), offset, + aopGet (right, offset, FALSE, FALSE, DP2_RESULT_REG)); } else { - char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL); + char *rOp = aopGet (right, offset, FALSE, FALSE, NULL); if (!strcmp(rOp, "a") || !strcmp(rOp, "acc")) { emitcode("mov", "b,a"); rOp = "b"; } - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("xrl", "a,%s", rOp); } } - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } } - } release: - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } /*-----------------------------------------------------------------*/ @@ -7635,13 +8158,11 @@ genInline (iCode * ic) { char *buffer, *bp, *bp1; - D (emitcode (";", "genInline "); ); + D (emitcode (";", "genInline ")); _G.inLine += (!options.asmpeep); - buffer = Safe_strdup(IC_INLINE(ic)); - bp = buffer; - bp1 = buffer; + buffer = bp = bp1 = Safe_strdup(IC_INLINE(ic)); /* emit each line as a code */ while (*bp) @@ -7654,7 +8175,8 @@ genInline (iCode * ic) } else { - if (*bp == ':') + /* Add \n for labels, not dirs such as c:\mydir */ + if ( (*bp == ':') && (isspace((unsigned char)bp[1])) ) { bp++; *bp = '\0'; @@ -7680,8 +8202,9 @@ genRRC (iCode * ic) { operand *left, *result; int size, offset; + char *l; - D (emitcode (";", "genRRC ");); + D (emitcode (";", "genRRC")); /* rotate right with carry */ left = IC_LEFT (ic); @@ -7697,10 +8220,11 @@ genRRC (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + l = aopGet (left, offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("rrc", "a"); if (AOP_SIZE (result) > 1) - aopPut (AOP (result), "a", offset--); + aopPut (result, "a", offset--); } _endLazyDPSEvaluation (); @@ -7708,12 +8232,13 @@ genRRC (iCode * ic) highest order byte of the result */ if (AOP_SIZE (result) > 1) { - MOVA (aopGet (AOP (result), AOP_SIZE (result) - 1, FALSE, FALSE, NULL)); + l = aopGet (result, AOP_SIZE (result) - 1, FALSE, FALSE, NULL); + MOVA (l); } emitcode ("mov", "acc.7,c"); - aopPut (AOP (result), "a", AOP_SIZE (result) - 1); - freeAsmop (left, NULL, ic, TRUE); + aopPut (result, "a", AOP_SIZE (result) - 1); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7726,7 +8251,7 @@ genRLC (iCode * ic) int size, offset; char *l; - D (emitcode (";", "genRLC ");); + D (emitcode (";", "genRLC ")); /* rotate right with carry */ left = IC_LEFT (ic); @@ -7739,22 +8264,22 @@ genRLC (iCode * ic) offset = 0; if (size--) { - l = aopGet (AOP (left), offset, FALSE, FALSE, NULL); + l = aopGet (left, offset, FALSE, FALSE, NULL); MOVA (l); emitcode ("add", "a,acc"); if (AOP_SIZE (result) > 1) { - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } _startLazyDPSEvaluation (); while (size--) { - l = aopGet (AOP (left), offset, FALSE, FALSE, NULL); + l = aopGet (left, offset, FALSE, FALSE, NULL); MOVA (l); emitcode ("rlc", "a"); if (AOP_SIZE (result) > 1) - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } _endLazyDPSEvaluation (); } @@ -7762,13 +8287,13 @@ genRLC (iCode * ic) highest order byte of the result */ if (AOP_SIZE (result) > 1) { - l = aopGet (AOP (result), 0, FALSE, FALSE, NULL); + l = aopGet (result, 0, FALSE, FALSE, NULL); MOVA (l); } emitcode ("mov", "acc.0,c"); - aopPut (AOP (result), "a", 0); - freeAsmop (left, NULL, ic, TRUE); + aopPut (result, "a", 0); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7778,15 +8303,16 @@ static void genGetHbit (iCode * ic) { operand *left, *result; + + D (emitcode (";", "genGetHbit")); + left = IC_LEFT (ic); result = IC_RESULT (ic); aopOp (left, ic, FALSE, FALSE); aopOp (result, ic, FALSE, AOP_USESDPTR(left)); - D (emitcode (";", "genGetHbit ");); - /* get the highest order byte into a */ - MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE, NULL)); + MOVA (aopGet (left, AOP_SIZE (left) - 1, FALSE, FALSE, NULL)); if (AOP_TYPE (result) == AOP_CRY) { emitcode ("rlc", "a"); @@ -7800,8 +8326,8 @@ genGetHbit (iCode * ic) } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7823,35 +8349,40 @@ genSwap (iCode * ic) switch (AOP_SIZE (left)) { case 1: /* swap nibbles in byte */ - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); emitcode ("swap", "a"); - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); break; case 2: /* swap bytes in word */ if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result))) { - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); - aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0); - aopPut (AOP (result), "a", 1); + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); + aopPut (result, aopGet (left, 1, FALSE, FALSE, NULL), 0); + aopPut (result, "a", 1); } else if (operandsEqu (left, result)) { char * reg = "a"; - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + bool pushedB = FALSE, leftInB = FALSE; + + MOVA (aopGet (left, 0, FALSE, FALSE, NULL)); if (AOP_NEEDSACC (left) || AOP_NEEDSACC (result)) { + pushedB = pushB (); emitcode ("mov", "b,a"); reg = "b"; - _G.bInUse=1; + leftInB = TRUE; } - aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0); - aopPut (AOP (result), reg, 1); - _G.bInUse=0; + aopPut (result, aopGet (left, 1, FALSE, FALSE, NULL), 0); + aopPut (result, reg, 1); + + if (leftInB) + popB (pushedB); } else { - aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0); - aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE, NULL), 1); + aopPut (result, aopGet (left, 1, FALSE, FALSE, NULL), 0); + aopPut (result, aopGet (left, 0, FALSE, FALSE, NULL), 1); } break; default: @@ -7859,8 +8390,8 @@ genSwap (iCode * ic) } _endLazyDPSEvaluation (); - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7998,13 +8529,13 @@ shiftR1Left2Result (operand * left, int offl, operand * result, int offr, int shCount, int sign) { - MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offl, FALSE, FALSE, NULL)); /* shift right accumulator */ if (sign) AccSRsh (shCount); else AccRsh (shCount); - aopPut (AOP (result), "a", offr); + aopPut (result, "a", offr); } #endif @@ -8016,10 +8547,12 @@ static void shiftL1Left2Result (operand * left, int offl, operand * result, int offr, int shCount) { - MOVA(aopGet (AOP (left), offl, FALSE, FALSE, NULL)); + char *l; + l = aopGet (left, offl, FALSE, FALSE, NULL); + MOVA (l); /* shift left accumulator */ AccLsh (shCount); - aopPut (AOP (result), "a", offr); + aopPut (result, "a", offr); } #endif @@ -8034,26 +8567,26 @@ movLeft2Result (operand * left, int offl, char *l; if (!sameRegs (AOP (left), AOP (result)) || (offl != offr)) { - l = aopGet (AOP (left), offl, FALSE, FALSE, NULL); + l = aopGet (left, offl, FALSE, FALSE, NULL); if (*l == '@' && (IS_AOP_PREG (result))) { emitcode ("mov", "a,%s", l); - aopPut (AOP (result), "a", offr); + aopPut (result, "a", offr); } else { if (!sign) { - aopPut (AOP (result), l, offr); + aopPut (result, l, offr); } else { /* MSB sign in acc.7 ! */ if (getDataSize (left) == offl + 1) { - emitcode ("mov", "a,%s", l); - aopPut (AOP (result), "a", offr); + MOVA (l); + aopPut (result, "a", offr); } } } @@ -8407,24 +8940,24 @@ _loadLeftIntoAx(char **lsb, if (AOP_TYPE(left) == AOP_DPTR2) { // Get MSB in A. - MOVA(aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offl + MSB16, FALSE, FALSE, NULL)); // get LSB in DP2_RESULT_REG. - leftByte = aopGet(AOP(left), offl, FALSE, FALSE, DP2_RESULT_REG); + leftByte = aopGet (left, offl, FALSE, FALSE, DP2_RESULT_REG); assert(!strcmp(leftByte, DP2_RESULT_REG)); } else { // get LSB into DP2_RESULT_REG - leftByte = aopGet (AOP(left), offl, FALSE, FALSE, NULL); + leftByte = aopGet (left, offl, FALSE, FALSE, NULL); if (strcmp(leftByte, DP2_RESULT_REG)) { TR_AP("#7"); emitcode("mov","%s,%s", DP2_RESULT_REG, leftByte); } // And MSB in A. - leftByte = aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL); + leftByte = aopGet (left, offl + MSB16, FALSE, FALSE, NULL); assert(strcmp(leftByte, DP2_RESULT_REG)); - MOVA(leftByte); + MOVA (leftByte); } _endLazyDPSEvaluation(); *lsb = DP2_RESULT_REG; @@ -8435,16 +8968,16 @@ _loadLeftIntoAx(char **lsb, ((offl + MSB16) == offr)) { /* don't crash result[offr] */ - MOVA(aopGet(AOP(left), offl, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offl, FALSE, FALSE, NULL)); emitcode ("xch", "a,%s", - aopGet(AOP(left), offl + MSB16, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, offl + MSB16, FALSE, FALSE, DP2_RESULT_REG)); } else { movLeft2Result (left, offl, result, offr, 0); - MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offl + MSB16, FALSE, FALSE, NULL)); } - *lsb = aopGet(AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG); + *lsb = aopGet (result, offr, FALSE, FALSE, DP2_RESULT_REG); assert(strcmp(*lsb,"a")); } } @@ -8459,13 +8992,13 @@ _storeAxResults(char *lsb, { /* We have to explicitly update the result LSB. */ - emitcode("xch","a,%s", lsb); - aopPut(AOP(result), "a", offr); - emitcode("mov","a,%s", lsb); + emitcode ("xch","a,%s", lsb); + aopPut (result, "a", offr); + emitcode ("mov","a,%s", lsb); } if (getDataSize (result) > 1) { - aopPut (AOP (result), "a", offr + MSB16); + aopPut (result, "a", offr + MSB16); } _endLazyDPSEvaluation(); } @@ -8521,14 +9054,14 @@ static void shiftLLeftOrResult (operand * left, int offl, operand * result, int offr, int shCount) { - MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offl, FALSE, FALSE, NULL)); /* shift left accumulator */ AccLsh (shCount); /* or with result */ emitcode ("orl", "a,%s", - aopGet (AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (result, offr, FALSE, FALSE, DP2_RESULT_REG)); /* back to result */ - aopPut (AOP (result), "a", offr); + aopPut (result, "a", offr); } #if 0 @@ -8540,14 +9073,14 @@ static void shiftRLeftOrResult (operand * left, int offl, operand * result, int offr, int shCount) { - MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offl, FALSE, FALSE, NULL)); /* shift right accumulator */ AccRsh (shCount); /* or with result */ emitcode ("orl", "a,%s", - aopGet (AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (result, offr, FALSE, FALSE, DP2_RESULT_REG)); /* back to result */ - aopPut (AOP (result), "a", offr); + aopPut (result, "a", offr); } #endif @@ -8558,7 +9091,8 @@ shiftRLeftOrResult (operand * left, int offl, static void genlshOne (operand * result, operand * left, int shCount) { - D (emitcode (";", "genlshOne ");); + D (emitcode (";", "genlshOne ")); + shiftL1Left2Result (left, LSB, result, LSB, shCount); } #endif @@ -8572,7 +9106,7 @@ genlshTwo (operand * result, operand * left, int shCount) { int size; - D (emitcode (";", "genlshTwo ");); + D (emitcode (";", "genlshTwo")); size = getDataSize (result); @@ -8589,18 +9123,18 @@ genlshTwo (operand * result, operand * left, int shCount) { _endLazyDPSEvaluation(); shiftL1Left2Result (left, LSB, result, MSB16, shCount); - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, LSB); } else { movLeft2Result (left, LSB, result, MSB16, 0); - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, LSB); _endLazyDPSEvaluation(); } } else { - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, LSB); _endLazyDPSEvaluation(); } } @@ -8609,14 +9143,10 @@ genlshTwo (operand * result, operand * left, int shCount) else { if (size == 1) - { shiftL1Left2Result (left, LSB, result, LSB, shCount); - } else - { shiftL2Left2Result (left, LSB, result, LSB, shCount); } - } } #endif @@ -8634,58 +9164,61 @@ shiftLLong (operand * left, operand * result, int offr) if (size >= LSB + offr) { - l = aopGet (AOP (left), LSB, FALSE, FALSE, NULL); + l = aopGet (left, LSB, FALSE, FALSE, NULL); MOVA (l); emitcode ("add", "a,acc"); if (sameRegs (AOP (left), AOP (result)) && size >= MSB16 + offr && offr != LSB) emitcode ("xch", "a,%s", - aopGet (AOP (left), LSB + offr, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, LSB + offr, FALSE, FALSE, DP2_RESULT_REG)); else - aopPut (AOP (result), "a", LSB + offr); + aopPut (result, "a", LSB + offr); } if (size >= MSB16 + offr) { if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB16 + offr && offr != LSB)) { - MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, TRUE)); + l = aopGet (left, MSB16, FALSE, FALSE, TRUE); + MOVA (l); } emitcode ("rlc", "a"); if (sameRegs (AOP (left), AOP (result)) && size >= MSB24 + offr && offr != LSB) emitcode ("xch", "a,%s", - aopGet (AOP (left), MSB16 + offr, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, MSB16 + offr, FALSE, FALSE, DP2_RESULT_REG)); else - aopPut (AOP (result), "a", MSB16 + offr); + aopPut (result, "a", MSB16 + offr); } if (size >= MSB24 + offr) { - if (!(sameRegs (AOP (left), AOP (left)) && size >= MSB24 + offr && offr != LSB)) + if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB24 + offr && offr != LSB)) { - MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL)); + l = aopGet (left, MSB24, FALSE, FALSE, NULL); + MOVA (l); } emitcode ("rlc", "a"); if (sameRegs (AOP (left), AOP (result)) && size >= MSB32 + offr && offr != LSB) emitcode ("xch", "a,%s", - aopGet (AOP (left), MSB24 + offr, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, MSB24 + offr, FALSE, FALSE, DP2_RESULT_REG)); else - aopPut (AOP (result), "a", MSB24 + offr); + aopPut (result, "a", MSB24 + offr); } if (size > MSB32 + offr) { if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB32 + offr && offr != LSB)) { - MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL)); + l = aopGet (left, MSB32, FALSE, FALSE, NULL); + MOVA (l); } emitcode ("rlc", "a"); - aopPut (AOP (result), "a", MSB32 + offr); + aopPut (result, "a", MSB32 + offr); } if (offr != LSB) - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, LSB); } #endif @@ -8699,8 +9232,7 @@ genlshFour (operand * result, operand * left, int shCount) { int size; - D (emitcode (";", "genlshFour "); - ); + D (emitcode (";", "genlshFour ")); size = AOP_SIZE (result); @@ -8714,9 +9246,9 @@ genlshFour (operand * result, operand * left, int shCount) shiftL1Left2Result (left, LSB, result, MSB32, shCount); else movLeft2Result (left, LSB, result, MSB32, 0); - aopPut (AOP (result), zero, LSB); - aopPut (AOP (result), zero, MSB16); - aopPut (AOP (result), zero, MSB24); + aopPut (result, zero, LSB); + aopPut (result, zero, MSB16); + aopPut (result, zero, MSB24); return; } @@ -8733,8 +9265,8 @@ genlshFour (operand * result, operand * left, int shCount) movLeft2Result (left, MSB16, result, MSB32, 0); movLeft2Result (left, LSB, result, MSB24, 0); } - aopPut (AOP (result), zero, MSB16); - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, MSB16); + aopPut (result, zero, LSB); return; } @@ -8757,7 +9289,7 @@ genlshFour (operand * result, operand * left, int shCount) movLeft2Result (left, MSB24, result, MSB32, 0); movLeft2Result (left, MSB16, result, MSB24, 0); movLeft2Result (left, LSB, result, MSB16, 0); - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, LSB); } else if (shCount == 1) shiftLLong (left, result, MSB16); @@ -8766,7 +9298,7 @@ genlshFour (operand * result, operand * left, int shCount) shiftL2Left2Result (left, MSB16, result, MSB24, shCount); shiftL1Left2Result (left, LSB, result, MSB16, shCount); shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount); - aopPut (AOP (result), zero, LSB); + aopPut (result, zero, LSB); } } } @@ -8859,7 +9391,7 @@ genLeftShiftLiteral (operand * left, _startLazyDPSEvaluation(); while (size--) { - aopPut (AOP (result), zero, size); + aopPut (result, zero, size); } _endLazyDPSEvaluation(); } @@ -8884,8 +9416,8 @@ genLeftShiftLiteral (operand * left, break; } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); return TRUE; } #endif @@ -8900,8 +9432,9 @@ genLeftShift (iCode * ic) int size, offset; char *l; symbol *tlbl, *tlbl1; + bool pushedB; - D (emitcode (";", "genLeftShift ");); + D (emitcode (";", "genLeftShift ")); right = IC_RIGHT (ic); left = IC_LEFT (ic); @@ -8928,6 +9461,7 @@ genLeftShift (iCode * ic) more that 32 bits make no sense anyway, ( the largest size of an object can be only 32 bits ) */ + pushedB = pushB (); if (AOP_TYPE (right) == AOP_LIT) { /* Really should be handled by genLeftShiftLiteral, @@ -8939,15 +9473,14 @@ genLeftShift (iCode * ic) } else { - MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b")); + MOVB (aopGet (right, 0, FALSE, FALSE, "b")); emitcode ("inc", "b"); } freeAsmop (right, NULL, ic, TRUE); aopOp (left, ic, FALSE, FALSE); aopOp (result, ic, FALSE, AOP_USESDPTR(left)); - /* now move the left to the result if they are not the - same */ + /* now move the left to the result if they are not the same */ if (!sameRegs (AOP (left), AOP (result)) && AOP_SIZE (result) > 1) { @@ -8957,15 +9490,15 @@ genLeftShift (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - l = aopGet (AOP (left), offset, FALSE, TRUE, NULL); + l = aopGet (left, offset, FALSE, TRUE, NULL); if (*l == '@' && (IS_AOP_PREG (result))) { emitcode ("mov", "a,%s", l); - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } else - aopPut (AOP (result), l, offset); + aopPut (result, l, offset); offset++; } _endLazyDPSEvaluation (); @@ -8981,13 +9514,15 @@ genLeftShift (iCode * ic) { symbol *tlbl1 = newiTempLabel (NULL); - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + l = aopGet (left, 0, FALSE, FALSE, NULL); + MOVA (l); emitcode ("sjmp", "!tlabel", tlbl1->key + 100); emitcode ("", "!tlabeldef", tlbl->key + 100); emitcode ("add", "a,acc"); emitcode ("", "!tlabeldef", tlbl1->key + 100); emitcode ("djnz", "b,!tlabel", tlbl->key + 100); - aopPut (AOP (result), "a", 0); + popB (pushedB); + aopPut (result, "a", 0); goto release; } @@ -8995,24 +9530,27 @@ genLeftShift (iCode * ic) emitcode ("sjmp", "!tlabel", tlbl1->key + 100); emitcode ("", "!tlabeldef", tlbl->key + 100); - MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL)); + l = aopGet (result, offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("add", "a,acc"); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); _startLazyDPSEvaluation (); while (--size) { - MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL)); + l = aopGet (result, offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("rlc", "a"); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } _endLazyDPSEvaluation (); reAdjustPreg (AOP (result)); emitcode ("", "!tlabeldef", tlbl1->key + 100); emitcode ("djnz", "b,!tlabel", tlbl->key + 100); + popB (pushedB); release: - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } #ifdef BETTER_LITERAL_SHIFT @@ -9023,7 +9561,7 @@ static void genrshOne (operand * result, operand * left, int shCount, int sign) { - D (emitcode (";", "genrshOne");); + D (emitcode (";", "genrshOne")); shiftR1Left2Result (left, LSB, result, LSB, shCount, sign); } #endif @@ -9036,7 +9574,7 @@ static void genrshTwo (operand * result, operand * left, int shCount, int sign) { - D (emitcode (";", "genrshTwo");); + D (emitcode (";", "genrshTwo")); /* if shCount >= 8 */ if (shCount >= 8) @@ -9044,23 +9582,16 @@ genrshTwo (operand * result, operand * left, shCount -= 8; _startLazyDPSEvaluation(); if (shCount) - { - shiftR1Left2Result (left, MSB16, result, LSB, - shCount, sign); - } + shiftR1Left2Result (left, MSB16, result, LSB, shCount, sign); else - { movLeft2Result (left, MSB16, result, LSB, sign); - } addSign (result, MSB16, sign); _endLazyDPSEvaluation(); } /* 1 <= shCount <= 7 */ else - { shiftR2Left2Result (left, LSB, result, LSB, shCount, sign); - } } #endif @@ -9079,52 +9610,59 @@ shiftRLong (operand * left, int offl, werror(E_INTERNAL_ERROR, __FILE__, __LINE__); } - MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL)); + MOVA (aopGet (left, MSB32, FALSE, FALSE, NULL)); - if (offl==MSB16) { - // shift is > 8 - if (sign) { - emitcode ("rlc", "a"); - emitcode ("subb", "a,acc"); - emitcode ("xch", "a,%s", - aopGet(AOP(left), MSB32, FALSE, FALSE, DP2_RESULT_REG)); - } else { - aopPut (AOP(result), zero, MSB32); + if (offl==MSB16) + { + // shift is > 8 + if (sign) + { + emitcode ("rlc", "a"); + emitcode ("subb", "a,acc"); + emitcode ("xch", "a,%s", + aopGet(left, MSB32, FALSE, FALSE, DP2_RESULT_REG)); + } + else + { + aopPut (result, zero, MSB32); + } } - } - if (!sign) { - emitcode ("clr", "c"); - } else { - emitcode ("mov", "c,acc.7"); - } + if (!sign) + { + emitcode ("clr", "c"); + } + else + { + emitcode ("mov", "c,acc.7"); + } emitcode ("rrc", "a"); if (isSameRegs && offl==MSB16) { emitcode ("xch", - "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE, DP2_RESULT_REG)); + "a,%s",aopGet (left, MSB24, FALSE, FALSE, DP2_RESULT_REG)); } else { - aopPut (AOP (result), "a", MSB32); - MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL)); + aopPut (result, "a", MSB32); + MOVA (aopGet (left, MSB24, FALSE, FALSE, NULL)); } emitcode ("rrc", "a"); if (isSameRegs && offl==1) { emitcode ("xch", "a,%s", - aopGet (AOP (left), MSB16, FALSE, FALSE, DP2_RESULT_REG)); + aopGet (left, MSB16, FALSE, FALSE, DP2_RESULT_REG)); } else { - aopPut (AOP (result), "a", MSB24); - MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, NULL)); + aopPut (result, "a", MSB24); + MOVA (aopGet (left, MSB16, FALSE, FALSE, NULL)); } emitcode ("rrc", "a"); - aopPut (AOP (result), "a", MSB16 - offl); + aopPut (result, "a", MSB16 - offl); if (offl == LSB) { - MOVA (aopGet (AOP (left), LSB, FALSE, FALSE, NULL)); + MOVA (aopGet (left, LSB, FALSE, FALSE, NULL)); emitcode ("rrc", "a"); - aopPut (AOP (result), "a", LSB); + aopPut (result, "a", LSB); } } @@ -9135,7 +9673,7 @@ static void genrshFour (operand * result, operand * left, int shCount, int sign) { - D (emitcode (";", "genrshFour");); + D (emitcode (";", "genrshFour")); /* if shifting more that 3 bytes */ if (shCount >= 24) @@ -9253,9 +9791,7 @@ genRightShiftLiteral (operand * left, size = getDataSize (result); _startLazyDPSEvaluation(); while (size--) - { movLeft2Result (left, size, result, size, 0); - } _endLazyDPSEvaluation(); } else if (shCount >= (size * 8)) @@ -9263,7 +9799,7 @@ genRightShiftLiteral (operand * left, if (sign) { /* get sign in acc.7 */ - MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE, NULL)); + MOVA (aopGet (left, size - 1, FALSE, FALSE, NULL)); } addSign (result, LSB, sign); } @@ -9287,8 +9823,8 @@ genRightShiftLiteral (operand * left, break; } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); return TRUE; } @@ -9304,8 +9840,9 @@ genSignedRightShift (iCode * ic) int size, offset; char *l; symbol *tlbl, *tlbl1; + bool pushedB; - D (emitcode (";", "genSignedRightShift ");); + D (emitcode (";", "genSignedRightShift")); /* we do it the hard way put the shift count in b and loop thru preserving the sign */ @@ -9331,6 +9868,7 @@ genSignedRightShift (iCode * ic) more that 32 bits make no sense anyway, ( the largest size of an object can be only 32 bits ) */ + pushedB = pushB (); if (AOP_TYPE (right) == AOP_LIT) { /* Really should be handled by genRightShiftLiteral, @@ -9342,7 +9880,7 @@ genSignedRightShift (iCode * ic) } else { - MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b")); + MOVB (aopGet (right, 0, FALSE, FALSE, "b")); emitcode ("inc", "b"); } freeAsmop (right, NULL, ic, TRUE); @@ -9360,15 +9898,15 @@ genSignedRightShift (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - l = aopGet (AOP (left), offset, FALSE, TRUE, NULL); + l = aopGet (left, offset, FALSE, TRUE, NULL); if (*l == '@' && IS_AOP_PREG (result)) { emitcode ("mov", "a,%s", l); - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } else - aopPut (AOP (result), l, offset); + aopPut (result, l, offset); offset++; } _endLazyDPSEvaluation (); @@ -9380,20 +9918,22 @@ genSignedRightShift (iCode * ic) size = AOP_SIZE (result); offset = size - 1; - MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL)); + MOVA (aopGet (left, offset, FALSE, FALSE, NULL)); emitcode ("rlc", "a"); emitcode ("mov", "ov,c"); /* if it is only one byte then */ if (size == 1) { - MOVA( aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + l = aopGet (left, 0, FALSE, FALSE, NULL); + MOVA (l); emitcode ("sjmp", "!tlabel", tlbl1->key + 100); emitcode ("", "!tlabeldef", tlbl->key + 100); emitcode ("mov", "c,ov"); emitcode ("rrc", "a"); emitcode ("", "!tlabeldef", tlbl1->key + 100); emitcode ("djnz", "b,!tlabel", tlbl->key + 100); - aopPut (AOP (result), "a", 0); + popB (pushedB); + aopPut (result, "a", 0); goto release; } @@ -9404,18 +9944,20 @@ genSignedRightShift (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL)); + l = aopGet (result, offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("rrc", "a"); - aopPut (AOP (result), "a", offset--); + aopPut (result, "a", offset--); } _endLazyDPSEvaluation (); reAdjustPreg (AOP (result)); emitcode ("", "!tlabeldef", tlbl1->key + 100); emitcode ("djnz", "b,!tlabel", tlbl->key + 100); + popB (pushedB); release: - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9429,8 +9971,9 @@ genRightShift (iCode * ic) int size, offset; char *l; symbol *tlbl, *tlbl1; + bool pushedB; - D (emitcode (";", "genRightShift ");); + D (emitcode (";", "genRightShift")); /* if signed then we do it the hard way preserve the sign bit moving it inwards */ @@ -9473,6 +10016,7 @@ genRightShift (iCode * ic) more that 32 bits make no sense anyway, ( the largest size of an object can be only 32 bits ) */ + pushedB = pushB (); if (AOP_TYPE (right) == AOP_LIT) { /* Really should be handled by genRightShiftLiteral, @@ -9484,7 +10028,7 @@ genRightShift (iCode * ic) } else { - MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b")); + MOVB (aopGet (right, 0, FALSE, FALSE, "b")); emitcode ("inc", "b"); } freeAsmop (right, NULL, ic, TRUE); @@ -9496,21 +10040,20 @@ genRightShift (iCode * ic) if (!sameRegs (AOP (left), AOP (result)) && AOP_SIZE (result) > 1) { - size = AOP_SIZE (result); offset = 0; _startLazyDPSEvaluation (); while (size--) { - l = aopGet (AOP (left), offset, FALSE, TRUE, NULL); + l = aopGet (left, offset, FALSE, TRUE, NULL); if (*l == '@' && IS_AOP_PREG (result)) { emitcode ("mov", "a,%s", l); - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } else - aopPut (AOP (result), l, offset); + aopPut (result, l, offset); offset++; } _endLazyDPSEvaluation (); @@ -9524,14 +10067,16 @@ genRightShift (iCode * ic) /* if it is only one byte then */ if (size == 1) { - MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL)); + l = aopGet (left, 0, FALSE, FALSE, NULL); + MOVA (l); emitcode ("sjmp", "!tlabel", tlbl1->key + 100); emitcode ("", "!tlabeldef", tlbl->key + 100); CLRC; emitcode ("rrc", "a"); emitcode ("", "!tlabeldef", tlbl1->key + 100); emitcode ("djnz", "b,!tlabel", tlbl->key + 100); - aopPut (AOP (result), "a", 0); + popB (pushedB); + aopPut (result, "a", 0); goto release; } @@ -9542,22 +10087,23 @@ genRightShift (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL)); + l = aopGet (result, offset, FALSE, FALSE, NULL); + MOVA (l); emitcode ("rrc", "a"); - aopPut (AOP (result), "a", offset--); + aopPut (result, "a", offset--); } _endLazyDPSEvaluation (); reAdjustPreg (AOP (result)); emitcode ("", "!tlabeldef", tlbl1->key + 100); emitcode ("djnz", "b,!tlabel", tlbl->key + 100); + popB (pushedB); release: - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } - /*-----------------------------------------------------------------*/ /* emitPtrByteGet - emits code to get a byte into A through a */ /* pointer register (R0, R1, or DPTR). The */ @@ -9679,7 +10225,7 @@ genUnpackBits (operand * result, char *rname, int ptype) emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << blen)); emitcode ("", "%05d$:", tlbl->key + 100); } - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); goto finish; } @@ -9688,7 +10234,7 @@ genUnpackBits (operand * result, char *rname, int ptype) for (rlen=blen;rlen>=8;rlen-=8) { emitPtrByteGet (rname, ptype, FALSE); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); if (rlen>8) emitcode ("inc", "%s", rname); } @@ -9707,7 +10253,7 @@ genUnpackBits (operand * result, char *rname, int ptype) emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << rlen)); emitcode ("", "%05d$:", tlbl->key + 100); } - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } finish: @@ -9727,7 +10273,7 @@ finish: } rsize -= offset; while (rsize--) - aopPut (AOP (result), source, offset++); + aopPut (result, source, offset++); } } @@ -9741,32 +10287,32 @@ genDataPointerGet (operand * left, iCode * ic) { char *l; - char buff[256]; + char buffer[256]; int size, offset = 0; aopOp (result, ic, TRUE, FALSE); /* get the string representation of the name */ - l = aopGet (AOP (left), 0, FALSE, TRUE, NULL); + l = aopGet (left, 0, FALSE, TRUE, NULL); size = AOP_SIZE (result); _startLazyDPSEvaluation (); while (size--) { if (offset) { - SNPRINTF (buff, sizeof(buff), + SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", l + 1, offset); } else { - SNPRINTF (buff, sizeof(buff), + SNPRINTF (buffer, sizeof(buffer), "%s", l + 1); } - aopPut (AOP (result), buff, offset++); + aopPut (result, buffer, offset++); } _endLazyDPSEvaluation (); - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9783,7 +10329,7 @@ genNearPointerGet (operand * left, char *rname; sym_link *rtype, *retype, *letype; sym_link *ltype = operandType (left); - char buff[80]; + char buffer[80]; rtype = operandType (result); retype = getSpec (rtype); @@ -9813,11 +10359,11 @@ genNearPointerGet (operand * left, preg = getFreePtr (ic, &aop, FALSE); emitcode ("mov", "%s,%s", preg->name, - aopGet (AOP (left), 0, FALSE, TRUE, DP2_RESULT_REG)); + aopGet (left, 0, FALSE, TRUE, DP2_RESULT_REG)); rname = preg->name; } else - rname = aopGet (AOP (left), 0, FALSE, FALSE, DP2_RESULT_REG); + rname = aopGet (left, 0, FALSE, FALSE, DP2_RESULT_REG); freeAsmop (left, NULL, ic, TRUE); aopOp (result, ic, FALSE, FALSE); @@ -9837,27 +10383,24 @@ genNearPointerGet (operand * left, { emitcode ("mov", "a,@%s", rname); - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); } else { - SNPRINTF (buff, sizeof(buff), "@%s", rname); - aopPut (AOP (result), buff, offset); + SNPRINTF (buffer, sizeof(buffer), "@%s", rname); + aopPut (result, buffer, offset); } offset++; if (size || pi) - { emitcode ("inc", "%s", rname); } } - } /* now some housekeeping stuff */ - if (aop) + if (aop) /* we had to allocate for this iCode */ { - /* we had to allocate for this iCode */ if (pi) { /* post increment present */ - aopPut(AOP ( left ),rname,0); + aopPut (left, rname, 0); } freeAsmop (NULL, aop, ic, TRUE); } @@ -9913,11 +10456,11 @@ genPagedPointerGet (operand * left, preg = getFreePtr (ic, &aop, FALSE); emitcode ("mov", "%s,%s", preg->name, - aopGet (AOP (left), 0, FALSE, TRUE, NULL)); + aopGet (left, 0, FALSE, TRUE, NULL)); rname = preg->name; } else - rname = aopGet (AOP (left), 0, FALSE, FALSE, NULL); + rname = aopGet (left, 0, FALSE, FALSE, NULL); freeAsmop (left, NULL, ic, TRUE); aopOp (result, ic, FALSE, FALSE); @@ -9935,7 +10478,7 @@ genPagedPointerGet (operand * left, { emitcode ("movx", "a,@%s", rname); - aopPut (AOP (result), "a", offset); + aopPut (result, "a", offset); offset++; @@ -9945,10 +10488,9 @@ genPagedPointerGet (operand * left, } /* now some housekeeping stuff */ - if (aop) + if (aop) /* we had to allocate for this iCode */ { - /* we had to allocate for this iCode */ - if (pi) aopPut ( AOP (left), rname, 0); + if (pi) aopPut (left, rname, 0); freeAsmop (NULL, aop, ic, TRUE); } else @@ -9976,7 +10518,7 @@ genPagedPointerGet (operand * left, } /*-----------------------------------------------------------------*/ -/* genFarPointerGet - gget value from far space */ +/* genFarPointerGet - get value from far space */ /*-----------------------------------------------------------------*/ static void genFarPointerGet (operand * left, @@ -9993,10 +10535,10 @@ genFarPointerGet (operand * left, then we do nothing else we move the value to dptr */ if (AOP_TYPE (left) != AOP_STR && !AOP_INDPTRn(left) ) { - /* if this is remateriazable */ + /* if this is rematerializable */ if (AOP_TYPE (left) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (left, 0, TRUE, FALSE, NULL)); } else { @@ -10004,19 +10546,19 @@ genFarPointerGet (operand * left, _startLazyDPSEvaluation (); if (AOP_TYPE (left) != AOP_DPTR) { - emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (left, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (left, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (left, 2, FALSE, FALSE, NULL)); } else { /* We need to generate a load to DPTR indirect through DPTR. */ D (emitcode (";", "genFarPointerGet -- indirection special case.");); - emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (left, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (left, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (left, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); dopi =0; @@ -10048,7 +10590,7 @@ genFarPointerGet (operand * left, if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD)) emitcode ("inc", "dptr"); genSetDPTR (0); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } } else { _startLazyDPSEvaluation (); @@ -10064,7 +10606,7 @@ genFarPointerGet (operand * left, if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD)) emitcode ("inc", "dptr"); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } _endLazyDPSEvaluation (); } @@ -10072,10 +10614,10 @@ genFarPointerGet (operand * left, if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) { if (!AOP_INDPTRn(left)) { _startLazyDPSEvaluation (); - aopPut ( AOP (left), "dpl", 0); - aopPut ( AOP (left), "dph", 1); + aopPut (left, "dpl", 0); + aopPut (left, "dph", 1); if (options.model == MODEL_FLAT24) - aopPut ( AOP (left), "dpx", 2); + aopPut (left, "dpx", 2); _endLazyDPSEvaluation (); } pi->generated = 1; @@ -10114,29 +10656,29 @@ genCodePointerGet (operand * left, then we do nothing else we move the value to dptr */ if (AOP_TYPE (left) != AOP_STR && !AOP_INDPTRn(left)) { - /* if this is remateriazable */ + /* if this is rematerializable */ if (AOP_TYPE (left) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (left, 0, TRUE, FALSE, NULL)); } else { /* we need to get it byte by byte */ _startLazyDPSEvaluation (); if (AOP_TYPE (left) != AOP_DPTR) { - emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (left, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (left, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (left, 2, FALSE, FALSE, NULL)); } else { /* We need to generate a load to DPTR indirect through DPTR. */ D (emitcode (";", "gencodePointerGet -- indirection special case.");); - emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (left, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (left, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (left, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); dopi=0; @@ -10168,7 +10710,7 @@ genCodePointerGet (operand * left, if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD)) emitcode ("inc", "dptr"); genSetDPTR (0); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } } else { _startLazyDPSEvaluation (); @@ -10185,7 +10727,7 @@ genCodePointerGet (operand * left, emitcode ("movc", "a,@a+dptr"); if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD)) emitcode ("inc", "dptr"); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } _endLazyDPSEvaluation (); } @@ -10194,10 +10736,10 @@ genCodePointerGet (operand * left, if (!AOP_INDPTRn(left)) { _startLazyDPSEvaluation (); - aopPut ( AOP (left), "dpl", 0); - aopPut ( AOP (left), "dph", 1); + aopPut (left, "dpl", 0); + aopPut (left, "dph", 1); if (options.model == MODEL_FLAT24) - aopPut ( AOP (left), "dpx", 2); + aopPut (left, "dpx", 2); _endLazyDPSEvaluation (); } @@ -10216,8 +10758,8 @@ genCodePointerGet (operand * left, } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10228,13 +10770,15 @@ genGenPointerGet (operand * left, operand * result, iCode * ic, iCode * pi) { int size, offset; + bool pushedB; sym_link *retype = getSpec (operandType (result)); sym_link *letype = getSpec (operandType (left)); - D (emitcode (";", "genGenPointerGet "); ); + D (emitcode (";", "genGenPointerGet")); aopOp (left, ic, FALSE, (AOP_IS_STR(left) ? FALSE : TRUE)); + pushedB = pushB (); /* if the operand is already in dptr then we do nothing else we move the value to dptr */ if (AOP_TYPE (left) != AOP_STR) @@ -10242,10 +10786,10 @@ genGenPointerGet (operand * left, /* if this is rematerializable */ if (AOP_TYPE (left) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (left, 0, TRUE, FALSE, NULL)); if (AOP(left)->aopu.aop_immd.from_cast_remat) { - MOVB(aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE, NULL)); + MOVB (aopGet (left, AOP_SIZE(left)-1, FALSE, FALSE, NULL)); } else { @@ -10255,22 +10799,20 @@ genGenPointerGet (operand * left, else { /* we need to get it byte by byte */ _startLazyDPSEvaluation (); - emitcode ("mov", "dpl,%s", aopGet (AOP(left),0,FALSE,FALSE,NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP(left),1,FALSE,FALSE,NULL)); + emitcode ("mov", "dpl,%s", aopGet (left,0,FALSE,FALSE,NULL)); + emitcode ("mov", "dph,%s", aopGet (left,1,FALSE,FALSE,NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,NULL)); - emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,NULL)); + emitcode ("mov", "dpx,%s", aopGet (left,2,FALSE,FALSE,NULL)); + emitcode ("mov", "b,%s", aopGet (left,3,FALSE,FALSE,NULL)); } else { - emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,NULL)); + emitcode ("mov", "b,%s", aopGet (left,2,FALSE,FALSE,NULL)); } _endLazyDPSEvaluation (); } } /* so dptr-b now contains the address */ - _G.bInUse++; aopOp (result, ic, FALSE, TRUE); - _G.bInUse--; /* if bit then unpack */ if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) @@ -10293,15 +10835,15 @@ genGenPointerGet (operand * left, // with the implementation of __gptrgetWord // in device/lib/_gptrget.c emitcode ("lcall", "__gptrgetWord"); - aopPut (AOP (result), DP2_RESULT_REG, offset++); - aopPut (AOP (result), "a", offset++); + aopPut (result, DP2_RESULT_REG, offset++); + aopPut (result, "a", offset++); size--; } else { // Only one byte to get. emitcode ("lcall", "__gptrget"); - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } if (size || (pi && AOP_TYPE (left) != AOP_IMMD)) @@ -10314,12 +10856,12 @@ genGenPointerGet (operand * left, if (pi && AOP_TYPE (left) != AOP_IMMD) { _startLazyDPSEvaluation (); - aopPut ( AOP (left), "dpl", 0); - aopPut ( AOP (left), "dph", 1); + aopPut (left, "dpl", 0); + aopPut (left, "dph", 1); if (options.model == MODEL_FLAT24) { - aopPut ( AOP (left), "dpx", 2); - aopPut ( AOP (left), "b", 3); - } else aopPut ( AOP (left), "b", 2); + aopPut (left, "dpx", 2); + aopPut (left, "b", 3); + } else aopPut (left, "b", 2); _endLazyDPSEvaluation (); @@ -10330,9 +10872,10 @@ genGenPointerGet (operand * left, size = AOP_SIZE (result) - 1; while (size--) emitcode ("lcall","__decdptr"); } + popB (pushedB); - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10345,8 +10888,7 @@ genPointerGet (iCode * ic, iCode *pi) sym_link *type, *etype; int p_type; - D (emitcode (";", "genPointerGet "); - ); + D (emitcode (";", "genPointerGet ")); left = IC_LEFT (ic); result = IC_RESULT (ic); @@ -10363,6 +10905,7 @@ genPointerGet (iCode * ic, iCode *pi) /* we have to go by the storage class */ p_type = PTR_TYPE (SPEC_OCLS (etype)); } + /* special case when cast remat */ if (p_type == GPOINTER && OP_SYMBOL(left)->remat && IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) @@ -10397,7 +10940,6 @@ genPointerGet (iCode * ic, iCode *pi) genGenPointerGet (left, result, ic, pi); break; } - } /*-----------------------------------------------------------------*/ @@ -10449,7 +10991,7 @@ genPackBits (sym_link * etype, emitcode ("mov", "c,%s", AOP(right)->aopu.aop_dir); else { - MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); emitcode ("rrc","a"); } emitPtrByteGet (rname, p_type, FALSE); @@ -10457,13 +10999,15 @@ genPackBits (sym_link * etype, } else { + bool pushedB; /* Case with a bitfield length < 8 and arbitrary source */ - MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); /* shift and mask source value */ AccLsh (bstr); emitcode ("anl", "a,#!constbyte", (~mask) & 0xff); + pushedB = pushB (); /* transfer A to B and get next byte */ emitPtrByteGet (rname, p_type, TRUE); @@ -10471,6 +11015,8 @@ genPackBits (sym_link * etype, emitcode ("orl", "a,b"); if (p_type == GPOINTER) emitcode ("pop", "b"); + + popB (pushedB); } } @@ -10483,7 +11029,7 @@ genPackBits (sym_link * etype, for (rlen=blen;rlen>=8;rlen-=8) { emitPtrByteSet (rname, p_type, - aopGet (AOP (right), offset++, FALSE, TRUE, NULL) ); + aopGet (right, offset++, FALSE, TRUE, NULL) ); if (rlen>8) emitcode ("inc", "%s", rname); } @@ -10508,11 +11054,13 @@ genPackBits (sym_link * etype, } else { + bool pushedB; /* Case with partial byte and arbitrary source */ - MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset++, FALSE, FALSE, NULL)); emitcode ("anl", "a,#!constbyte", (~mask) & 0xff); + pushedB = pushB (); /* transfer A to B and get next byte */ emitPtrByteGet (rname, p_type, TRUE); @@ -10520,10 +11068,11 @@ genPackBits (sym_link * etype, emitcode ("orl", "a,b"); if (p_type == GPOINTER) emitcode ("pop", "b"); + + popB (pushedB); } emitPtrByteSet (rname, p_type, "a"); } - } @@ -10536,29 +11085,26 @@ genDataPointerSet (operand * right, iCode * ic) { int size, offset = 0; - char *l, buff[256]; + char *l, buffer[256]; + + D (emitcode (";", "genDataPointerSet")); aopOp (right, ic, FALSE, FALSE); - l = aopGet (AOP (result), 0, FALSE, TRUE, NULL); + l = aopGet (result, 0, FALSE, TRUE, NULL); size = AOP_SIZE (right); while (size--) { if (offset) - { - SNPRINTF (buff, sizeof(buff), "(%s + %d)", l + 1, offset); - } + SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", l + 1, offset); else - { - SNPRINTF (buff, sizeof(buff), "%s", l + 1); - } - - emitcode ("mov", "%s,%s", buff, - aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); + SNPRINTF (buffer, sizeof(buffer), "%s", l + 1); + emitcode ("mov", "%s,%s", buffer, + aopGet (right, offset++, FALSE, FALSE, NULL)); } - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10575,6 +11121,8 @@ genNearPointerSet (operand * right, sym_link *retype, *letype; sym_link *ptype = operandType (result); + D(emitcode (";", "genNearPointerSet")); + retype = getSpec (operandType (right)); letype = getSpec (ptype); @@ -10602,11 +11150,13 @@ genNearPointerSet (operand * right, preg = getFreePtr (ic, &aop, FALSE); emitcode ("mov", "%s,%s", preg->name, - aopGet (AOP (result), 0, FALSE, TRUE, NULL)); + aopGet (result, 0, FALSE, TRUE, NULL)); rname = preg->name; } else - rname = aopGet (AOP (result), 0, FALSE, FALSE, NULL); + { + rname = aopGet (result, 0, FALSE, FALSE, NULL); + } aopOp (right, ic, FALSE, FALSE); @@ -10621,7 +11171,7 @@ genNearPointerSet (operand * right, while (size--) { - l = aopGet (AOP (right), offset, FALSE, TRUE, NULL); + l = aopGet (right, offset, FALSE, TRUE, NULL); if (*l == '@') { MOVA (l); @@ -10636,10 +11186,9 @@ genNearPointerSet (operand * right, } /* now some housekeeping stuff */ - if (aop) + if (aop) /* we had to allocate for this iCode */ { - /* we had to allocate for this iCode */ - if (pi) aopPut (AOP (result),rname,0); + if (pi) aopPut (result,rname,0); freeAsmop (NULL, aop, ic, TRUE); } else @@ -10665,8 +11214,6 @@ genNearPointerSet (operand * right, if (pi) pi->generated = 1; freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, TRUE); - - } /*-----------------------------------------------------------------*/ @@ -10679,9 +11226,11 @@ genPagedPointerSet (operand * right, iCode *pi) { asmop *aop = NULL; - char *rname; + char *rname, *l; sym_link *retype, *letype; + D (emitcode (";", "genPagedPointerSet")); + retype = getSpec (operandType (right)); letype = getSpec (operandType (result)); @@ -10698,11 +11247,11 @@ genPagedPointerSet (operand * right, preg = getFreePtr (ic, &aop, FALSE); emitcode ("mov", "%s,%s", preg->name, - aopGet (AOP (result), 0, FALSE, TRUE, NULL)); + aopGet (result, 0, FALSE, TRUE, NULL)); rname = preg->name; } else - rname = aopGet (AOP (result), 0, FALSE, FALSE, NULL); + rname = aopGet (result, 0, FALSE, FALSE, NULL); aopOp (right, ic, FALSE, FALSE); @@ -10717,8 +11266,8 @@ genPagedPointerSet (operand * right, while (size--) { - MOVA (aopGet (AOP (right), offset, FALSE, TRUE, NULL)); - + l = aopGet (right, offset, FALSE, TRUE, NULL); + MOVA (l); emitcode ("movx", "@%s,a", rname); if (size || pi) @@ -10731,7 +11280,8 @@ genPagedPointerSet (operand * right, /* now some housekeeping stuff */ if (aop) { - if (pi) aopPut (AOP (result),rname,0); + if (pi) + aopPut (result, rname, 0); /* we had to allocate for this iCode */ freeAsmop (NULL, aop, ic, TRUE); } @@ -10758,8 +11308,6 @@ genPagedPointerSet (operand * right, if (pi) pi->generated = 1; freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, TRUE); - - } /*-----------------------------------------------------------------*/ @@ -10782,27 +11330,27 @@ genFarPointerSet (operand * right, /* if this is remateriazable */ if (AOP_TYPE (result) == AOP_IMMD) emitcode ("mov", "dptr,%s", - aopGet (AOP (result), 0, TRUE, FALSE, NULL)); + aopGet (result, 0, TRUE, FALSE, NULL)); else { /* we need to get it byte by byte */ _startLazyDPSEvaluation (); if (AOP_TYPE (result) != AOP_DPTR) { - emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (result, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (result, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (result, 2, FALSE, FALSE, NULL)); } else { /* We need to generate a load to DPTR indirect through DPTR. */ D (emitcode (";", "genFarPointerSet -- indirection special case.");); - emitcode ("push", "%s", aopGet (AOP (result), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (result), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (result, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (result, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (result, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); dopi=0; @@ -10814,7 +11362,8 @@ genFarPointerSet (operand * right, aopOp (right, ic, FALSE, (AOP_INDPTRn(result) ? FALSE : TRUE)); /* if bit then unpack */ - if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) { + if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) + { if (AOP_INDPTRn(result)) { genSetDPTR(AOP(result)->aopu.dptr); } @@ -10827,7 +11376,7 @@ genFarPointerSet (operand * right, offset = 0; if (AOP_INDPTRn(result) && AOP_USESDPTR(right)) { while (size--) { - MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset++, FALSE, FALSE, NULL)); genSetDPTR(AOP(result)->aopu.dptr); emitcode ("movx", "@dptr,a"); @@ -10838,7 +11387,7 @@ genFarPointerSet (operand * right, } else { _startLazyDPSEvaluation (); while (size--) { - MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset++, FALSE, FALSE, NULL)); if (AOP_INDPTRn(result)) { genSetDPTR(AOP(result)->aopu.dptr); @@ -10859,10 +11408,10 @@ genFarPointerSet (operand * right, if (!AOP_INDPTRn(result)) { _startLazyDPSEvaluation (); - aopPut (AOP(result),"dpl",0); - aopPut (AOP(result),"dph",1); + aopPut (result,"dpl",0); + aopPut (result,"dph",1); if (options.model == MODEL_FLAT24) - aopPut (AOP(result),"dpx",2); + aopPut (result,"dpx",2); _endLazyDPSEvaluation (); } @@ -10892,11 +11441,13 @@ genGenPointerSet (operand * right, operand * result, iCode * ic, iCode *pi) { int size, offset; + bool pushedB; sym_link *retype = getSpec (operandType (right)); sym_link *letype = getSpec (operandType (result)); aopOp (result, ic, FALSE, AOP_IS_STR(result) ? FALSE : TRUE); + pushedB = pushB (); /* if the operand is already in dptr then we do nothing else we move the value to dptr */ if (AOP_TYPE (result) != AOP_STR) @@ -10905,35 +11456,32 @@ genGenPointerSet (operand * right, /* if this is remateriazable */ if (AOP_TYPE (result) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (result, 0, TRUE, FALSE, NULL)); if (AOP(result)->aopu.aop_immd.from_cast_remat) { - MOVB(aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, NULL)); + MOVB (aopGet (result, AOP_SIZE(result)-1, FALSE, FALSE, NULL)); } else { emitcode ("mov", - "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, NULL)); + "b,%s + 1", aopGet (result, 0, TRUE, FALSE, NULL)); } } else { /* we need to get it byte by byte */ - emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (result, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (result, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL)); - emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (result, 2, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet (result, 3, FALSE, FALSE, NULL)); } else { - emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "b,%s", aopGet (result, 2, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); } /* so dptr + b now contains the address */ - _G.bInUse++; aopOp (right, ic, FALSE, TRUE); - _G.bInUse--; - /* if bit then unpack */ if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) @@ -10957,8 +11505,8 @@ genGenPointerSet (operand * right, // with the implementation of __gptrputWord // in device/lib/_gptrput.c emitcode("mov", "_ap, %s", - aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); - MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); + aopGet (right, offset++, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset++, FALSE, FALSE, NULL)); genSetDPTR (0); _flushLazyDPS (); @@ -10968,7 +11516,7 @@ genGenPointerSet (operand * right, else { // Only one byte to put. - MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL)); + MOVA (aopGet (right, offset++, FALSE, FALSE, NULL)); genSetDPTR (0); _flushLazyDPS (); @@ -10986,13 +11534,13 @@ genGenPointerSet (operand * right, if (pi && AOP_TYPE (result) != AOP_IMMD) { _startLazyDPSEvaluation (); - aopPut (AOP(result),"dpl",0); - aopPut (AOP(result),"dph",1); + aopPut (result, "dpl",0); + aopPut (result, "dph",1); if (options.model == MODEL_FLAT24) { - aopPut (AOP(result),"dpx",2); - aopPut (AOP(result),"b",3); + aopPut (result, "dpx",2); + aopPut (result, "b",3); } else { - aopPut (AOP(result),"b",2); + aopPut (result, "b",2); } _endLazyDPSEvaluation (); @@ -11003,6 +11551,8 @@ genGenPointerSet (operand * right, size = AOP_SIZE (right) - 1; while (size--) emitcode ("lcall","__decdptr"); } + popB (pushedB); + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, TRUE); } @@ -11017,7 +11567,7 @@ genPointerSet (iCode * ic, iCode *pi) sym_link *type, *etype; int p_type; - D (emitcode (";", "genPointerSet ");); + D (emitcode (";", "genPointerSet")); right = IC_RIGHT (ic); result = IC_RESULT (ic); @@ -11036,6 +11586,7 @@ genPointerSet (iCode * ic, iCode *pi) /* we have to go by the storage class */ p_type = PTR_TYPE (SPEC_OCLS (etype)); } + /* special case when cast remat */ if (p_type == GPOINTER && OP_SYMBOL(result)->remat && IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) { @@ -11070,7 +11621,6 @@ genPointerSet (iCode * ic, iCode *pi) werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "genPointerSet: illegal pointer type"); } - } /*-----------------------------------------------------------------*/ @@ -11081,8 +11631,9 @@ genIfx (iCode * ic, iCode * popIc) { operand *cond = IC_COND (ic); int isbit = 0; + char *dup = NULL; - D (emitcode (";", "genIfx ");); + D (emitcode (";", "genIfx ")); aopOp (cond, ic, FALSE, FALSE); @@ -11094,9 +11645,11 @@ genIfx (iCode * ic, iCode * popIc) else { isbit = 1; + if (AOP(cond)->aopu.aop_dir) + dup = Safe_strdup(AOP(cond)->aopu.aop_dir); } - /* the result is now in the accumulator */ + /* the result is now in the accumulator or a directly addressable bit */ freeAsmop (cond, NULL, ic, TRUE); /* if there was something to be popped then do it */ @@ -11104,8 +11657,11 @@ genIfx (iCode * ic, iCode * popIc) genIpop (popIc); /* if the condition is a bit variable */ - if (isbit && IS_ITEMP (cond) && - SPIL_LOC (cond)) + if (isbit && dup) + { + genIfxJump (ic, dup); + } + else if (isbit && IS_ITEMP (cond) && SPIL_LOC (cond)) { genIfxJump (ic, SPIL_LOC (cond)->rname); } @@ -11130,15 +11686,15 @@ genAddrOf (iCode * ic) symbol *sym = OP_SYMBOL (IC_LEFT (ic)); int size, offset; - D (emitcode (";", "genAddrOf "); - ); + D (emitcode (";", "genAddrOf")); aopOp (IC_RESULT (ic), ic, FALSE, FALSE); /* if the operand is on the stack then we need to get the stack offset of this variable */ - if (sym->onStack) { + if (sym->onStack) + { /* if 10 bit stack */ if (options.stack10bit) { @@ -11170,25 +11726,28 @@ genAddrOf (iCode * ic) emitcode ("addc","a,#!constbyte", offset); - aopPut (AOP (IC_RESULT (ic)), "b", 0); - aopPut (AOP (IC_RESULT (ic)), "a", 1); - aopPut (AOP (IC_RESULT (ic)), buff, 2); + aopPut (IC_RESULT (ic), "b", 0); + aopPut (IC_RESULT (ic), "a", 1); + aopPut (IC_RESULT (ic), buff, 2); } else { /* we can just move _bp */ - aopPut (AOP (IC_RESULT (ic)), "_bpx", 0); - aopPut (AOP (IC_RESULT (ic)), "_bpx+1", 1); - aopPut (AOP (IC_RESULT (ic)), buff, 2); + aopPut (IC_RESULT (ic), "_bpx", 0); + aopPut (IC_RESULT (ic), "_bpx+1", 1); + aopPut (IC_RESULT (ic), buff, 2); } } else { /* if it has an offset then we need to compute it */ - if (sym->stack) { + if (sym->stack) + { emitcode ("mov", "a,_bp"); emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff)); - aopPut (AOP (IC_RESULT (ic)), "a", 0); - } else { + aopPut (IC_RESULT (ic), "a", 0); + } + else + { /* we can just move _bp */ - aopPut (AOP (IC_RESULT (ic)), "_bp", 0); - } + aopPut (IC_RESULT (ic), "_bp", 0); + } /* fill the result with zero */ size = AOP_SIZE (IC_RESULT (ic)) - 1; @@ -11199,8 +11758,9 @@ genAddrOf (iCode * ic) } offset = 1; - while (size--) { - aopPut (AOP (IC_RESULT (ic)), zero, offset++); + while (size--) + { + aopPut (IC_RESULT (ic), zero, offset++); } } goto release; @@ -11235,7 +11795,7 @@ genAddrOf (iCode * ic) SNPRINTF (s, sizeof(s), "#%s", sym->rname); } - aopPut (AOP (IC_RESULT (ic)), s, offset++); + aopPut (IC_RESULT (ic), s, offset++); } release: @@ -11265,7 +11825,7 @@ genArrayInit (iCode * ic) { // Load immediate value into DPTR. emitcode("mov", "dptr, %s", - aopGet(AOP(IC_LEFT(ic)), 0, TRUE, FALSE, NULL)); + aopGet (IC_LEFT(ic), 0, TRUE, FALSE, NULL)); } else if (AOP_TYPE(IC_LEFT(ic)) != AOP_DPTR) { @@ -11275,10 +11835,10 @@ genArrayInit (iCode * ic) exit(1); #else // a regression because of SDCCcse.c:1.52 - emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (left, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (left, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (left, 2, FALSE, FALSE, NULL)); #endif } @@ -11368,13 +11928,13 @@ genFarFarAssign (operand * result, operand * right, iCode * ic) { /* quick & easy case. */ D(emitcode(";","genFarFarAssign (1 byte case)");); - MOVA(aopGet(AOP(right), 0, FALSE, FALSE, NULL)); + MOVA (aopGet (right, 0, FALSE, FALSE, NULL)); freeAsmop (right, NULL, ic, FALSE); /* now assign DPTR to result */ _G.accInUse++; aopOp(result, ic, FALSE, FALSE); _G.accInUse--; - aopPut(AOP(result), "a", 0); + aopPut (result, "a", 0); freeAsmop(result, NULL, ic, FALSE); return; } @@ -11444,8 +12004,8 @@ no time to test now, so later well put in...kpb while (size--) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), offset); + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; } _endLazyDPSEvaluation (); @@ -11464,8 +12024,7 @@ genAssign (iCode * ic) int size, offset; unsigned long lit = 0L; - D (emitcode (";", "genAssign "); - ); + D (emitcode (";", "genAssign ")); result = IC_RESULT (ic); right = IC_RIGHT (ic); @@ -11504,9 +12063,9 @@ genAssign (iCode * ic) if (AOP_TYPE (right) == AOP_LIT) { if (((int) operandLitValue (right))) - aopPut (AOP (result), one, 0); + aopPut (result, one, 0); else - aopPut (AOP (result), zero, 0); + aopPut (result, zero, 0); goto release; } @@ -11514,13 +12073,13 @@ genAssign (iCode * ic) if (AOP_TYPE (right) == AOP_CRY) { emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); - aopPut (AOP (result), "c", 0); + aopPut (result, "c", 0); goto release; } /* we need to or */ toBoolean (right); - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); goto release; } @@ -11539,8 +12098,8 @@ genAssign (iCode * ic) _startLazyDPSEvaluation (); while (size && ((unsigned int) (lit >> (offset * 8)) != 0)) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; size--; @@ -11552,7 +12111,7 @@ genAssign (iCode * ic) } while (size--) { - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } _endLazyDPSEvaluation (); } @@ -11561,8 +12120,8 @@ genAssign (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; } @@ -11570,8 +12129,8 @@ genAssign (iCode * ic) } release: - freeAsmop (right, NULL, ic, FALSE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -11588,7 +12147,7 @@ genJumpTab (iCode * ic) aopOp (IC_JTCOND (ic), ic, FALSE, FALSE); /* get the condition into accumulator */ - l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE, NULL); + l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE, NULL); MOVA (l); /* multiply by four! */ emitcode ("add", "a,acc"); @@ -11618,7 +12177,7 @@ genCast (iCode * ic) operand *right = IC_RIGHT (ic); int size, offset; - D (emitcode (";", "genCast ");); + D (emitcode (";", "genCast ")); /* if they are equivalent then do nothing */ if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic))) @@ -11636,9 +12195,9 @@ genCast (iCode * ic) if (AOP_TYPE (right) == AOP_LIT) { if (((int) operandLitValue (right))) - aopPut (AOP (result), one, 0); + aopPut (result, one, 0); else - aopPut (AOP (result), zero, 0); + aopPut (result, zero, 0); goto release; } @@ -11647,13 +12206,13 @@ genCast (iCode * ic) if (AOP_TYPE (right) == AOP_CRY) { emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); - aopPut (AOP (result), "c", 0); + aopPut (result, "c", 0); goto release; } /* we need to or */ toBoolean (right); - aopPut (AOP (result), "a", 0); + aopPut (result, "a", 0); goto release; } @@ -11671,8 +12230,8 @@ genCast (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; } @@ -11680,7 +12239,6 @@ genCast (iCode * ic) goto release; } - /* if the result is of type pointer */ if (IS_PTR (ctype)) { @@ -11742,8 +12300,8 @@ genCast (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; } @@ -11761,7 +12319,7 @@ genCast (iCode * ic) } SNPRINTF(gpValStr, sizeof(gpValStr), "#0x%x", gpVal); - aopPut (AOP (result), gpValStr, GPTRSIZE - 1); + aopPut (result, gpValStr, GPTRSIZE - 1); } goto release; } @@ -11772,8 +12330,8 @@ genCast (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; } @@ -11789,8 +12347,8 @@ genCast (iCode * ic) _startLazyDPSEvaluation (); while (size--) { - aopPut (AOP (result), - aopGet (AOP (right), offset, FALSE, FALSE, NULL), + aopPut (result, + aopGet (right, offset, FALSE, FALSE, NULL), offset); offset++; } @@ -11806,18 +12364,18 @@ genCast (iCode * ic) { while (size--) { - aopPut (AOP (result), zero, offset++); + aopPut (result, zero, offset++); } } else { /* we need to extend the sign :{ */ - MOVA (aopGet (AOP (right), AOP_SIZE (right) - 1, + MOVA (aopGet (right, AOP_SIZE (right) - 1, FALSE, FALSE, NULL)); emitcode ("rlc", "a"); emitcode ("subb", "a,acc"); while (size--) - aopPut (AOP (result), "a", offset++); + aopPut (result, "a", offset++); } /* we are done hurray !!!! */ @@ -11871,7 +12429,7 @@ genDjnz (iCode * ic, iCode * ifx) * the accumulator, we must explicitly write * it back after the decrement. */ - char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE, NULL); + char *rByte = aopGet(IC_RESULT(ic), 0, FALSE, FALSE, NULL); if (strcmp(rByte, "a")) { @@ -11885,19 +12443,19 @@ genDjnz (iCode * ic, iCode * ifx) return 0; } emitcode ("dec", "%s", rByte); - aopPut(AOP(IC_RESULT(ic)), rByte, 0); + aopPut(IC_RESULT(ic), rByte, 0); emitcode ("jnz", "!tlabel", lbl->key + 100); } else if (IS_AOP_PREG (IC_RESULT (ic))) { emitcode ("dec", "%s", - aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL)); + aopGet (IC_RESULT (ic), 0, FALSE, FALSE, NULL)); + emitcode ("mov", "a,%s", aopGet (IC_RESULT (ic), 0, FALSE, FALSE, NULL)); emitcode ("jnz", "!tlabel", lbl->key + 100); } else { - emitcode ("djnz", "%s,!tlabel", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, NULL), + emitcode ("djnz", "%s,!tlabel", aopGet (IC_RESULT (ic), 0, FALSE, TRUE, NULL), lbl->key + 100); } emitcode ("sjmp", "!tlabel", lbl1->key + 100); @@ -11920,7 +12478,7 @@ genReceive (iCode * ic) int offset = 0; int rb1off ; - D (emitcode (";", "genReceive ");); + D (emitcode (";", "genReceive ")); if (ic->argreg == 1) { @@ -11948,20 +12506,29 @@ genReceive (iCode * ic) werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "genReceive got unexpected DPTR."); } - assignResultValue (IC_RESULT (ic)); + assignResultValue (IC_RESULT (ic), NULL); + } + } + else if (ic->argreg > 12) + { /* bit parameters */ + if (OP_SYMBOL (IC_RESULT (ic))->regs[0]->rIdx != ic->argreg-5) + { + aopOp (IC_RESULT (ic), ic, FALSE, FALSE); + emitcode ("mov", "c,%s", rb1regs[ic->argreg-5]); + outBitC(IC_RESULT (ic)); } } else { /* second receive onwards */ - /* this gets a little tricky since unused recevies will be + /* this gets a little tricky since unused receives will be eliminated, we have saved the reg in the type field . and we use that to figure out which register to use */ aopOp (IC_RESULT (ic), ic, FALSE, FALSE); rb1off = ic->argreg; while (size--) { - aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++); + aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++); } } freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); @@ -11997,10 +12564,10 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc) aopOp (from, ic->next, FALSE, FALSE); /* get from into DPTR1 */ - emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl1,%s", aopGet (from, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph1,%s", aopGet (from, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx1,%s", aopGet (from, 2, FALSE, FALSE, NULL)); } freeAsmop (from, NULL, ic, FALSE); @@ -12011,22 +12578,22 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc) if (AOP_TYPE (to) != AOP_STR) { /* if already in DPTR then we need to push */ if (AOP_TYPE(to) == AOP_DPTR) { - emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); } else { _startLazyDPSEvaluation (); /* if this is remateriazable */ if (AOP_TYPE (to) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (to, 0, TRUE, FALSE, NULL)); } else { /* we need to get it byte by byte */ - emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (to, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (to, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); @@ -12040,7 +12607,7 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc) /* now for the actual copy */ if (AOP_TYPE(count) == AOP_LIT && (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) { - emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL)); + emitcode ("mov", "b,%s",aopGet(count,0,FALSE,FALSE,NULL)); if (fromc) { emitcode ("lcall","__bi_memcpyc2x_s"); } else { @@ -12051,8 +12618,8 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc) symbol *lbl1 = newiTempLabel(NULL); emitcode (";"," Auto increment but no djnz"); - emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL)); - emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL)); + emitcode ("mov","_ap,%s",aopGet (count, 0, FALSE, TRUE, NULL)); + emitcode ("mov","b,%s",aopGet (count, 1, FALSE, TRUE, NULL)); freeAsmop (count, NULL, ic, FALSE); emitcode ("mov", "dps,#!constbyte",0x21); /* Select DPTR2 & auto-toggle. */ emitcode ("","!tlabeldef",lbl->key+100); @@ -12112,10 +12679,10 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc) aopOp (from, ic->next, FALSE, FALSE); /* get from into DPTR1 */ - emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl1,%s", aopGet (from, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph1,%s", aopGet (from, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx1,%s", aopGet (from, 2, FALSE, FALSE, NULL)); } freeAsmop (from, NULL, ic, FALSE); @@ -12126,22 +12693,22 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc) if (AOP_TYPE (to) != AOP_STR) { /* if already in DPTR then we need to push */ if (AOP_TYPE(to) == AOP_DPTR) { - emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); } else { _startLazyDPSEvaluation (); /* if this is remateriazable */ if (AOP_TYPE (to) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (to, 0, TRUE, FALSE, NULL)); } else { /* we need to get it byte by byte */ - emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (to, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (to, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); @@ -12156,22 +12723,22 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc) /* now for the actual compare */ if (AOP_TYPE(count) == AOP_LIT && (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) { - emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL)); + emitcode ("mov", "b,%s",aopGet(count,0,FALSE,FALSE,NULL)); if (fromc) emitcode("lcall","__bi_memcmpc2x_s"); else emitcode("lcall","__bi_memcmpx2x_s"); freeAsmop (count, NULL, ic, FALSE); aopOp (IC_RESULT(ic), ic, FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } else { symbol *lbl1 = newiTempLabel(NULL); emitcode("push","ar0"); emitcode (";"," Auto increment but no djnz"); - emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL)); - emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL)); + emitcode ("mov","_ap,%s",aopGet (count, 0, FALSE, TRUE, NULL)); + emitcode ("mov","b,%s",aopGet (count, 1, FALSE, TRUE, NULL)); freeAsmop (count, NULL, ic, FALSE); emitcode ("mov", "dps,#!constbyte",0x21); /* Select DPTR2 & auto-toggle. */ emitcode ("","!tlabeldef",lbl->key+100); @@ -12201,7 +12768,7 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc) emitcode ("clr","a"); emitcode ("","!tlabeldef",lbl2->key+100); aopOp (IC_RESULT(ic), ic, FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); emitcode("pop","ar0"); emitcode ("mov", "dps,#0"); @@ -12243,10 +12810,10 @@ static void genInp( iCode *ic, int nparms, operand **parms) aopOp (from, ic->next, FALSE, FALSE); /* get from into DPTR1 */ - emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl1,%s", aopGet (from, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph1,%s", aopGet (from, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx1,%s", aopGet (from, 2, FALSE, FALSE, NULL)); } freeAsmop (from, NULL, ic, FALSE); @@ -12257,22 +12824,22 @@ static void genInp( iCode *ic, int nparms, operand **parms) if (AOP_TYPE (to) != AOP_STR) { /* if already in DPTR then we need to push */ if (AOP_TYPE(to) == AOP_DPTR) { - emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); } else { _startLazyDPSEvaluation (); /* if this is remateriazable */ if (AOP_TYPE (to) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (to, 0, TRUE, FALSE, NULL)); } else { /* we need to get it byte by byte */ - emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (to, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (to, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); @@ -12289,7 +12856,7 @@ static void genInp( iCode *ic, int nparms, operand **parms) (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) { emitcode (";","OH JOY auto increment with djnz (very fast)"); emitcode ("mov", "dps,#!constbyte",0x1); /* Select DPTR2 */ - emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL)); + emitcode ("mov", "b,%s",aopGet(count,0,FALSE,FALSE,NULL)); freeAsmop (count, NULL, ic, FALSE); emitcode ("","!tlabeldef",lbl->key+100); emitcode ("movx", "a,@dptr"); /* read data from port */ @@ -12302,8 +12869,8 @@ static void genInp( iCode *ic, int nparms, operand **parms) symbol *lbl1 = newiTempLabel(NULL); emitcode (";"," Auto increment but no djnz"); - emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL)); - emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL)); + emitcode ("mov","_ap,%s",aopGet (count, 0, FALSE, TRUE, NULL)); + emitcode ("mov","b,%s",aopGet (count, 1, FALSE, TRUE, NULL)); freeAsmop (count, NULL, ic, FALSE); emitcode ("mov", "dps,#!constbyte",0x1); /* Select DPTR2 */ emitcode ("","!tlabeldef",lbl->key+100); @@ -12364,10 +12931,10 @@ static void genOutp( iCode *ic, int nparms, operand **parms) aopOp (from, ic->next, FALSE, FALSE); /* get from into DPTR1 */ - emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl1,%s", aopGet (from, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph1,%s", aopGet (from, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx1,%s", aopGet (from, 2, FALSE, FALSE, NULL)); } freeAsmop (from, NULL, ic, FALSE); @@ -12378,22 +12945,22 @@ static void genOutp( iCode *ic, int nparms, operand **parms) if (AOP_TYPE (to) != AOP_STR) { /* if already in DPTR then we need to push */ if (AOP_TYPE(to) == AOP_DPTR) { - emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); } else { _startLazyDPSEvaluation (); /* if this is remateriazable */ if (AOP_TYPE (to) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (to, 0, TRUE, FALSE, NULL)); } else { /* we need to get it byte by byte */ - emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (to, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (to, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); @@ -12410,7 +12977,7 @@ static void genOutp( iCode *ic, int nparms, operand **parms) (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) { emitcode (";","OH JOY auto increment with djnz (very fast)"); emitcode ("mov", "dps,#!constbyte",0x0); /* Select DPTR */ - emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL)); + emitcode ("mov", "b,%s",aopGet(count,0,FALSE,FALSE,NULL)); emitcode ("","!tlabeldef",lbl->key+100); emitcode ("movx", "a,@dptr"); /* read data from port */ emitcode ("inc","dps"); /* switch to DPTR2 */ @@ -12423,8 +12990,8 @@ static void genOutp( iCode *ic, int nparms, operand **parms) symbol *lbl1 = newiTempLabel(NULL); emitcode (";"," Auto increment but no djnz"); - emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL)); - emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL)); + emitcode ("mov","_ap,%s",aopGet (count, 0, FALSE, TRUE, NULL)); + emitcode ("mov","b,%s",aopGet (count, 1, FALSE, TRUE, NULL)); freeAsmop (count, NULL, ic, FALSE); emitcode ("mov", "dps,#!constbyte",0x0); /* Select DPTR */ emitcode ("","!tlabeldef",lbl->key+100); @@ -12466,15 +13033,15 @@ static void genSwapW(iCode *ic, int nparms, operand **parms) assert(getSize(operandType(src))==2); aopOp (src, ic, FALSE, FALSE); - emitcode ("mov","a,%s",aopGet(AOP(src),0,FALSE,FALSE,NULL)); + emitcode ("mov","a,%s",aopGet(src,0,FALSE,FALSE,NULL)); _G.accInUse++; - MOVB(aopGet(AOP(src),1,FALSE,FALSE,"b")); + MOVB(aopGet(src,1,FALSE,FALSE,"b")); _G.accInUse--; freeAsmop (src, NULL, ic, FALSE); aopOp (dest,ic, FALSE, FALSE); - aopPut(AOP(dest),"b",0); - aopPut(AOP(dest),"a",1); + aopPut(dest,"b",0); + aopPut(dest,"a",1); freeAsmop (dest, NULL, ic, FALSE); } @@ -12513,22 +13080,22 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms) if (AOP_TYPE (to) != AOP_STR) { /* if already in DPTR then we need to push */ if (AOP_TYPE(to) == AOP_DPTR) { - emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL)); - emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 0, FALSE, TRUE, NULL)); + emitcode ("push", "%s", aopGet (to, 1, FALSE, TRUE, NULL)); if (options.model == MODEL_FLAT24) - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); emitcode ("pop", "dph"); emitcode ("pop", "dpl"); } else { _startLazyDPSEvaluation (); /* if this is remateriazable */ if (AOP_TYPE (to) == AOP_IMMD) { - emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL)); + emitcode ("mov", "dptr,%s", aopGet (to, 0, TRUE, FALSE, NULL)); } else { /* we need to get it byte by byte */ - emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL)); - emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL)); + emitcode ("mov", "dpl,%s", aopGet (to, 0, FALSE, FALSE, NULL)); + emitcode ("mov", "dph,%s", aopGet (to, 1, FALSE, FALSE, NULL)); if (options.model == MODEL_FLAT24) { - emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL)); + emitcode ("mov", "dpx,%s", aopGet (to, 2, FALSE, FALSE, NULL)); } } _endLazyDPSEvaluation (); @@ -12542,8 +13109,8 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms) /* now for the actual copy */ if (AOP_TYPE(count) == AOP_LIT && (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) { - l = aopGet(AOP (val), 0, FALSE, FALSE, NULL); - emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL)); + l = aopGet(val, 0, FALSE, FALSE, NULL); + emitcode ("mov", "b,%s",aopGet(count,0,FALSE,FALSE,NULL)); MOVA(l); emitcode ("","!tlabeldef",lbl->key+100); emitcode ("movx", "@dptr,a"); @@ -12552,10 +13119,10 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms) } else { symbol *lbl1 = newiTempLabel(NULL); - emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL)); - emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL)); + emitcode ("mov","_ap,%s",aopGet (count, 0, FALSE, TRUE, NULL)); + emitcode ("mov","b,%s",aopGet (count, 1, FALSE, TRUE, NULL)); emitcode ("","!tlabeldef",lbl->key+100); - MOVA (aopGet(AOP (val), 0, FALSE, FALSE, NULL)); + MOVA (aopGet(val, 0, FALSE, FALSE, NULL)); emitcode ("movx", "@dptr,a"); emitcode ("inc", "dptr"); emitcode ("mov","a,b"); @@ -12590,7 +13157,7 @@ static void genNatLibLoadPrimitive(iCode *ic, int nparms, operand **parms,int si pnum = parms[0]; aopOp (pnum, ic, FALSE, FALSE); - emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,DP2_RESULT_REG)); + emitcode ("mov","a,%s",aopGet(pnum,0,FALSE,FALSE,DP2_RESULT_REG)); freeAsmop (pnum, NULL, ic, FALSE); emitcode ("lcall","NatLib_LoadPrimitive"); aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE); @@ -12601,11 +13168,11 @@ static void genNatLibLoadPrimitive(iCode *ic, int nparms, operand **parms,int si } for (i=0; i < size ; i++ ) { emitcode ("pop","a%s", - aopGet(AOP(result),i,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(result,i,FALSE,FALSE,DP2_RESULT_REG)); } } else { for (i = 0 ; i < size ; i++ ) { - aopPut(AOP(result),javaRet[i],i); + aopPut(result,javaRet[i],i); } } freeAsmop (result, NULL, ic, FALSE); @@ -12629,13 +13196,13 @@ static void genNatLibLoadPointer(iCode *ic, int nparms, operand **parms) pnum = parms[0]; aopOp (pnum, ic, FALSE, FALSE); - emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,DP2_RESULT_REG)); + emitcode ("mov","a,%s",aopGet(pnum,0,FALSE,FALSE,DP2_RESULT_REG)); freeAsmop (pnum, NULL, ic, FALSE); emitcode ("lcall","NatLib_LoadPointer"); aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE); if (AOP_TYPE(result)!=AOP_STR) { for (i = 0 ; i < size ; i++ ) { - aopPut(AOP(result),fReturn[i],i); + aopPut(result,fReturn[i],i); } } freeAsmop (result, NULL, ic, FALSE); @@ -12663,12 +13230,12 @@ static void genNatLibInstallStateBlock(iCode *ic, int nparms, if (AOP_TYPE (psb) == AOP_IMMD) { emitcode ("mov","dps,#1"); emitcode ("mov", "dptr,%s", - aopGet (AOP (psb), 0, TRUE, FALSE, DP2_RESULT_REG)); + aopGet (psb, 0, TRUE, FALSE, DP2_RESULT_REG)); emitcode ("mov","dps,#0"); } else { - emitcode ("mov","dpl1,%s",aopGet(AOP(psb),0,FALSE,FALSE,DP2_RESULT_REG)); - emitcode ("mov","dph1,%s",aopGet(AOP(psb),1,FALSE,FALSE,DP2_RESULT_REG)); - emitcode ("mov","dpx1,%s",aopGet(AOP(psb),2,FALSE,FALSE,DP2_RESULT_REG)); + emitcode ("mov","dpl1,%s",aopGet(psb,0,FALSE,FALSE,DP2_RESULT_REG)); + emitcode ("mov","dph1,%s",aopGet(psb,1,FALSE,FALSE,DP2_RESULT_REG)); + emitcode ("mov","dpx1,%s",aopGet(psb,2,FALSE,FALSE,DP2_RESULT_REG)); } freeAsmop (psb, NULL, ic, FALSE); @@ -12678,13 +13245,13 @@ static void genNatLibInstallStateBlock(iCode *ic, int nparms, /* put handle into r3:r2 */ aopOp (handle, ic, FALSE, FALSE); if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) { - emitcode ("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); - emitcode ("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + emitcode ("push","%s",aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); + emitcode ("push","%s",aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("pop","ar3"); emitcode ("pop","ar2"); } else { - emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); - emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + emitcode ("mov","r2,%s",aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); + emitcode ("mov","r3,%s",aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); } freeAsmop (psb, NULL, ic, FALSE); @@ -12695,7 +13262,7 @@ static void genNatLibInstallStateBlock(iCode *ic, int nparms, _G.accInUse++; aopOp (IC_RESULT(ic), ic, FALSE, FALSE); _G.accInUse--; - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); unsavermask(rsave); } @@ -12746,12 +13313,12 @@ static void genNatLibGetStateBlock(iCode *ic,int nparms, emitcode ("push","ar3"); emitcode ("push","ar2"); emitcode ("pop","%s", - aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(IC_RESULT(ic),0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("pop","%s", - aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(IC_RESULT(ic),1,FALSE,TRUE,DP2_RESULT_REG)); } else { - aopPut(AOP(IC_RESULT(ic)),"r2",0); - aopPut(AOP(IC_RESULT(ic)),"r3",1); + aopPut(IC_RESULT(ic),"r2",0); + aopPut(IC_RESULT(ic),"r3",1); } freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); emitcode ("","!tlabeldef",lbl->key+100); @@ -12779,19 +13346,19 @@ static void genMMMalloc (iCode *ic,int nparms, operand **parms, /* put the size in R4-R2 */ if (aopHasRegs(AOP(bsize),R2_IDX, (size==3 ? R4_IDX: R3_IDX))) { - emitcode("push","%s",aopGet(AOP(bsize),0,FALSE,TRUE,DP2_RESULT_REG)); - emitcode("push","%s",aopGet(AOP(bsize),1,FALSE,TRUE,DP2_RESULT_REG)); + emitcode("push","%s",aopGet(bsize,0,FALSE,TRUE,DP2_RESULT_REG)); + emitcode("push","%s",aopGet(bsize,1,FALSE,TRUE,DP2_RESULT_REG)); if (size==3) { - emitcode("push","%s",aopGet(AOP(bsize),2,FALSE,TRUE,DP2_RESULT_REG)); + emitcode("push","%s",aopGet(bsize,2,FALSE,TRUE,DP2_RESULT_REG)); emitcode("pop","ar4"); } emitcode("pop","ar3"); emitcode("pop","ar2"); } else { - emitcode ("mov","r2,%s",aopGet(AOP(bsize),0,FALSE,TRUE,DP2_RESULT_REG)); - emitcode ("mov","r3,%s",aopGet(AOP(bsize),1,FALSE,TRUE,DP2_RESULT_REG)); + emitcode ("mov","r2,%s",aopGet(bsize,0,FALSE,TRUE,DP2_RESULT_REG)); + emitcode ("mov","r3,%s",aopGet(bsize,1,FALSE,TRUE,DP2_RESULT_REG)); if (size==3) { - emitcode("mov","r4,%s",aopGet(AOP(bsize),2,FALSE,TRUE,DP2_RESULT_REG)); + emitcode("mov","r4,%s",aopGet(bsize,2,FALSE,TRUE,DP2_RESULT_REG)); } } freeAsmop (bsize, NULL, ic, FALSE); @@ -12810,12 +13377,12 @@ static void genMMMalloc (iCode *ic,int nparms, operand **parms, emitcode ("push","ar3"); emitcode ("push","ar2"); emitcode ("pop","%s", - aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(IC_RESULT(ic),0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("pop","%s", - aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(IC_RESULT(ic),1,FALSE,TRUE,DP2_RESULT_REG)); } else { - aopPut(AOP(IC_RESULT(ic)),"r2",0); - aopPut(AOP(IC_RESULT(ic)),"r3",1); + aopPut(IC_RESULT(ic),"r2",0); + aopPut(IC_RESULT(ic),"r3",1); } freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } @@ -12841,16 +13408,16 @@ static void genMMDeref (iCode *ic,int nparms, operand **parms) /* put the size in R4-R2 */ if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) { emitcode("push","%s", - aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode("push","%s", - aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); emitcode("pop","ar3"); emitcode("pop","ar2"); } else { emitcode ("mov","r2,%s", - aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("mov","r3,%s", - aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); } freeAsmop (handle, NULL, ic, FALSE); @@ -12864,9 +13431,9 @@ static void genMMDeref (iCode *ic,int nparms, operand **parms) if (AOP_TYPE(IC_RESULT(ic)) != AOP_STR) { _startLazyDPSEvaluation (); - aopPut(AOP(IC_RESULT(ic)),"dpl",0); - aopPut(AOP(IC_RESULT(ic)),"dph",1); - aopPut(AOP(IC_RESULT(ic)),"dpx",2); + aopPut(IC_RESULT(ic),"dpl",0); + aopPut(IC_RESULT(ic),"dph",1); + aopPut(IC_RESULT(ic),"dpx",2); _endLazyDPSEvaluation (); @@ -12896,16 +13463,16 @@ static void genMMUnrestrictedPersist(iCode *ic,int nparms, operand **parms) /* put the size in R3-R2 */ if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) { emitcode("push","%s", - aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode("push","%s", - aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); emitcode("pop","ar3"); emitcode("pop","ar2"); } else { emitcode ("mov","r2,%s", - aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("mov","r3,%s", - aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); } freeAsmop (handle, NULL, ic, FALSE); @@ -12916,7 +13483,7 @@ static void genMMUnrestrictedPersist(iCode *ic,int nparms, operand **parms) symbol *rsym = OP_SYMBOL(IC_RESULT(ic)); if (rsym->liveFrom != rsym->liveTo) { aopOp (IC_RESULT(ic),ic,FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } } @@ -12943,16 +13510,16 @@ static void genSystemExecJavaProcess(iCode *ic,int nparms, operand **parms) aopOp (handle,ic,FALSE,FALSE); if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) { emitcode("push","%s", - aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode("push","%s", - aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); emitcode("pop","ar3"); emitcode("pop","ar2"); } else { emitcode ("mov","r2,%s", - aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("mov","r3,%s", - aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(handle,1,FALSE,TRUE,DP2_RESULT_REG)); } freeAsmop (handle, NULL, ic, FALSE); @@ -12960,11 +13527,11 @@ static void genSystemExecJavaProcess(iCode *ic,int nparms, operand **parms) aopOp (pp,ic,FALSE,FALSE); if (AOP_TYPE(pp) == AOP_IMMD) { emitcode ("mov", "dptr,%s", - aopGet (AOP (pp), 0, TRUE, FALSE, NULL)); + aopGet (pp, 0, TRUE, FALSE, NULL)); } else if (AOP_TYPE(pp) != AOP_STR) { /* not already in dptr */ - emitcode ("mov","dpl,%s",aopGet(AOP(pp),0,FALSE,FALSE,NULL)); - emitcode ("mov","dph,%s",aopGet(AOP(pp),1,FALSE,FALSE,NULL)); - emitcode ("mov","dpx,%s",aopGet(AOP(pp),2,FALSE,FALSE,NULL)); + emitcode ("mov","dpl,%s",aopGet(pp,0,FALSE,FALSE,NULL)); + emitcode ("mov","dph,%s",aopGet(pp,1,FALSE,FALSE,NULL)); + emitcode ("mov","dpx,%s",aopGet(pp,2,FALSE,FALSE,NULL)); } freeAsmop (handle, NULL, ic, FALSE); @@ -12976,7 +13543,7 @@ static void genSystemExecJavaProcess(iCode *ic,int nparms, operand **parms) symbol *rsym = OP_SYMBOL(IC_RESULT(ic)); if (rsym->liveFrom != rsym->liveTo) { aopOp (IC_RESULT(ic),ic,FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } } @@ -13004,15 +13571,15 @@ static void genSystemRTCRegisters(iCode *ic,int nparms, operand **parms, if (AOP_TYPE (pp) == AOP_IMMD) { emitcode ("mov","dps,#1"); emitcode ("mov", "dptr,%s", - aopGet (AOP (pp), 0, TRUE, FALSE, NULL)); + aopGet (pp, 0, TRUE, FALSE, NULL)); emitcode ("mov","dps,#0"); } else { emitcode ("mov","dpl1,%s", - aopGet(AOP(pp),0,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(pp,0,FALSE,FALSE,DP2_RESULT_REG)); emitcode ("mov","dph1,%s", - aopGet(AOP(pp),1,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(pp,1,FALSE,FALSE,DP2_RESULT_REG)); emitcode ("mov","dpx1,%s", - aopGet(AOP(pp),2,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(pp,2,FALSE,FALSE,DP2_RESULT_REG)); } freeAsmop (pp, NULL, ic, FALSE); @@ -13040,26 +13607,26 @@ static void genSystemThreadSleep(iCode *ic,int nparms, operand **parms, char *na if (aopHasRegs(AOP(to),R2_IDX,R3_IDX) || aopHasRegs(AOP(to),R0_IDX,R1_IDX) ) { emitcode ("push","%s", - aopGet(AOP(to),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("push","%s", - aopGet(AOP(to),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,1,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("push","%s", - aopGet(AOP(to),2,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,2,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("push","%s", - aopGet(AOP(to),3,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,3,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("pop","ar3"); emitcode ("pop","ar2"); emitcode ("pop","ar1"); emitcode ("pop","ar0"); } else { emitcode ("mov","r0,%s", - aopGet(AOP(to),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,0,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("mov","r1,%s", - aopGet(AOP(to),1,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,1,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("mov","r2,%s", - aopGet(AOP(to),2,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,2,FALSE,TRUE,DP2_RESULT_REG)); emitcode ("mov","r3,%s", - aopGet(AOP(to),3,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(to,3,FALSE,TRUE,DP2_RESULT_REG)); } freeAsmop (to, NULL, ic, FALSE); @@ -13067,7 +13634,7 @@ static void genSystemThreadSleep(iCode *ic,int nparms, operand **parms, char *na s = parms[1]; aopOp(s,ic,FALSE,FALSE); emitcode ("mov","a,%s", - aopGet(AOP(s),0,FALSE,TRUE,NULL)); + aopGet(s,0,FALSE,TRUE,NULL)); freeAsmop (s, NULL, ic, FALSE); /* make the call */ @@ -13095,13 +13662,13 @@ static void genSystemThreadResume(iCode *ic,int nparms, operand **parms) /* PID in R0 */ aopOp(pid,ic,FALSE,FALSE); emitcode ("mov","r0,%s", - aopGet(AOP(pid),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(pid,0,FALSE,TRUE,DP2_RESULT_REG)); freeAsmop (pid, NULL, ic, FALSE); /* tid into ACC */ aopOp(tid,ic,FALSE,FALSE); emitcode ("mov","a,%s", - aopGet(AOP(tid),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(tid,0,FALSE,TRUE,DP2_RESULT_REG)); freeAsmop (tid, NULL, ic, FALSE); emitcode ("lcall","System_ThreadResume"); @@ -13111,7 +13678,7 @@ static void genSystemThreadResume(iCode *ic,int nparms, operand **parms) symbol *rsym = OP_SYMBOL(IC_RESULT(ic)); if (rsym->liveFrom != rsym->liveTo) { aopOp (IC_RESULT(ic),ic,FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } } @@ -13136,7 +13703,7 @@ static void genSystemProcessResume(iCode *ic,int nparms, operand **parms) /* pid into ACC */ aopOp(pid,ic,FALSE,FALSE); emitcode ("mov","a,%s", - aopGet(AOP(pid),0,FALSE,TRUE,DP2_RESULT_REG)); + aopGet(pid,0,FALSE,TRUE,DP2_RESULT_REG)); freeAsmop (pid, NULL, ic, FALSE); emitcode ("lcall","System_ProcessResume"); @@ -13171,14 +13738,14 @@ static void genSystemPoll(iCode *ic,int nparms, operand **parms,char *name) aopOp (fp,ic,FALSE,FALSE); if (AOP_TYPE (fp) == AOP_IMMD) { emitcode ("mov", "dptr,%s", - aopGet (AOP (fp), 0, TRUE, FALSE, DP2_RESULT_REG)); + aopGet (fp, 0, TRUE, FALSE, DP2_RESULT_REG)); } else if (AOP_TYPE(fp) != AOP_STR) { /* not already in dptr */ emitcode ("mov","dpl,%s", - aopGet(AOP(fp),0,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(fp,0,FALSE,FALSE,DP2_RESULT_REG)); emitcode ("mov","dph,%s", - aopGet(AOP(fp),1,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(fp,1,FALSE,FALSE,DP2_RESULT_REG)); emitcode ("mov","dpx,%s", - aopGet(AOP(fp),2,FALSE,FALSE,DP2_RESULT_REG)); + aopGet(fp,2,FALSE,FALSE,DP2_RESULT_REG)); } freeAsmop (fp, NULL, ic, FALSE); @@ -13189,7 +13756,7 @@ static void genSystemPoll(iCode *ic,int nparms, operand **parms,char *name) symbol *rsym = OP_SYMBOL(IC_RESULT(ic)); if (rsym->liveFrom != rsym->liveTo) { aopOp (IC_RESULT(ic),ic,FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } } @@ -13209,7 +13776,7 @@ static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *na symbol *rsym = OP_SYMBOL(IC_RESULT(ic)); if (rsym->liveFrom != rsym->liveTo) { aopOp (IC_RESULT(ic),ic,FALSE,FALSE); - aopPut(AOP(IC_RESULT(ic)),"a",0); + aopPut(IC_RESULT(ic),"a",0); freeAsmop (IC_RESULT(ic), NULL, ic, FALSE); } } @@ -13224,7 +13791,7 @@ genDummyRead (iCode * ic) operand *op; int size, offset; - D(emitcode("; genDummyRead","")); + D (emitcode(";", "genDummyRead")); op = IC_RIGHT (ic); if (op && IS_SYMOP (op)) @@ -13242,7 +13809,7 @@ genDummyRead (iCode * ic) offset = 0; while (size--) { - MOVA (aopGet (AOP (op), offset, FALSE, FALSE, FALSE)); + MOVA (aopGet (op, offset, FALSE, FALSE, FALSE)); offset++; } } @@ -13266,14 +13833,13 @@ genDummyRead (iCode * ic) offset = 0; while (size--) { - MOVA (aopGet (AOP (op), offset, FALSE, FALSE, FALSE)); + MOVA (aopGet (op, offset, FALSE, FALSE, FALSE)); offset++; } } freeAsmop (op, NULL, ic, TRUE); } - } /*-----------------------------------------------------------------*/ @@ -13284,7 +13850,7 @@ genCritical (iCode *ic) { symbol *tlbl = newiTempLabel (NULL); - D(emitcode("; genCritical","")); + D (emitcode(";", "genCritical")); if (IC_RESULT (ic)) aopOp (IC_RESULT (ic), ic, TRUE, FALSE); @@ -13321,7 +13887,7 @@ genEndCritical (iCode *ic) } else { - MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE, FALSE)); + MOVA (aopGet (IC_RIGHT (ic), 0, FALSE, FALSE, FALSE)); emitcode ("rrc", "a"); emitcode ("mov", "ea,c"); } @@ -13455,6 +14021,7 @@ gen390Code (iCode * lic) iCode *ic; int cln = 0; + _G.currentFunc = NULL; lineHead = lineCurr = NULL; dptrn[1][0] = "dpl1"; dptrn[1][1] = "dph1"; @@ -13692,8 +14259,10 @@ gen390Code (iCode * lic) break; case SEND: - if (ic->builtinSEND) genBuiltIn(ic); - else addSet (&_G.sendSet, ic); + if (ic->builtinSEND) + genBuiltIn(ic); + else + addSet (&_G.sendSet, ic); break; case DUMMY_READ_VOLATILE: diff --git a/src/ds390/gen.h b/src/ds390/gen.h index 907b9601..22b4f227 100644 --- a/src/ds390/gen.h +++ b/src/ds390/gen.h @@ -1,5 +1,5 @@ /*------------------------------------------------------------------------- - SDCCgen51.h - header file for code generation for 8051 + gen.h - header file for code generation for DS80C390 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998) @@ -7,23 +7,23 @@ under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - + In other words, you are welcome to use, share and improve this program. You are forbidden to forbid anyone else to use, share and improve - what you give them. Help stamp out software-hoarding! + what you give them. Help stamp out software-hoarding! -------------------------------------------------------------------------*/ -#ifndef SDCCGEN51_H -#define SDCCGEN51_H +#ifndef SDCCGEN390_H +#define SDCCGEN390_H enum { @@ -34,47 +34,47 @@ enum AOP_CRY, AOP_ACC, AOP_DPTRn, AOP_DUMMY }; -/* type asmop : a homogenised type for +/* type asmop : a homogenised type for all the different spaces an operand can be in */ typedef struct asmop { - short type; /* can have values - AOP_LIT - operand is a literal value - AOP_REG - is in registers - AOP_DIR - direct just a name - AOP_DPTR - dptr contains address of operand - AOP_DPTR2 - dptr2 contains address of operand (DS80C390 only). - AOP_R0/R1 - r0/r1 contains address of operand - AOP_STK - should be pushed on stack this - can happen only for the result - AOP_IMMD - immediate value for eg. remateriazable - AOP_CRY - carry contains the value of this - AOP_STR - array of strings - AOP_ACC - result is in the acc:b pair - AOP_DPTRn - is in dptr(n) - AOP_DUMMY - read as 0, discard writes - */ - short coff; /* current offset */ - short size; /* total size */ - unsigned code:1; /* is in Code space */ - unsigned paged:1; /* in paged memory */ - unsigned freed:1; /* already freed */ + short type; /* can have values + AOP_LIT - operand is a literal value + AOP_REG - is in registers + AOP_DIR - direct just a name + AOP_DPTR - dptr contains address of operand + AOP_DPTR2 - dptr2 contains address of operand (DS80C390 only). + AOP_R0/R1 - r0/r1 contains address of operand + AOP_STK - should be pushed on stack this + can happen only for the result + AOP_IMMD - immediate value for eg. remateriazable + AOP_CRY - carry contains the value of this + AOP_STR - array of strings + AOP_ACC - result is in the acc:b pair + AOP_DPTRn - is in dptr(n) + AOP_DUMMY - read as 0, discard writes + */ + short coff; /* current offset */ + short size; /* total size */ + unsigned code:1; /* is in Code space */ + unsigned paged:1; /* in paged memory */ + unsigned short allocated; /* number of times allocated */ union { - short dptr; /* if AOP_DPTRn */ - value *aop_lit; /* if literal */ - regs *aop_reg[4]; /* array of registers */ - char *aop_dir; /* if direct */ - regs *aop_ptr; /* either -> to r0 or r1 */ - struct { - int from_cast_remat; /* cast remat created this : immd2 field used for highest order*/ - char *aop_immd1; /* if immediate others are implied */ - char *aop_immd2; /* cast remat will generate this */ - } aop_immd; - int aop_stk; /* stack offset when AOP_STK */ - char *aop_str[5]; /* just a string array containing the location */ + short dptr; /* if AOP_DPTRn */ + value *aop_lit; /* if literal */ + regs *aop_reg[4]; /* array of registers */ + char *aop_dir; /* if direct */ + regs *aop_ptr; /* either -> to r0 or r1 */ + struct { + int from_cast_remat; /* cast remat created this : immd2 field used for highest order*/ + char *aop_immd1; /* if immediate others are implied */ + char *aop_immd2; /* cast remat will generate this */ + } aop_immd; + int aop_stk; /* stack offset when AOP_STK */ + char *aop_str[5]; /* just a string array containing the location */ } aopu; } diff --git a/src/ds390/main.c b/src/ds390/main.c index 202eb3b9..7f735daa 100644 --- a/src/ds390/main.c +++ b/src/ds390/main.c @@ -32,6 +32,8 @@ static char *_ds390_keywords[] = "pdata", "reentrant", "sfr", + "sfr16", + "sfr32", "sbit", "using", "xdata", diff --git a/src/ds390/ralloc.c b/src/ds390/ralloc.c index f91a0c63..7cd5870c 100644 --- a/src/ds390/ralloc.c +++ b/src/ds390/ralloc.c @@ -50,6 +50,7 @@ static struct bitVect *funcrUsed; /* registers used in a function */ int stackExtend; int dataExtend; + bitVect *allBitregs; /* all bit registers */ } _G; @@ -72,6 +73,14 @@ regs regs390[] = {REG_GPR, DPH_IDX, REG_GPR, "dph", "dph", "dph", 0, 0, 0}, {REG_GPR, DPX_IDX, REG_GPR, "dpx", "dpx", "dpx", 0, 0, 0}, {REG_GPR, B_IDX, REG_GPR, "b", "b", "b", 0, 0, 0}, + {REG_BIT, B0_IDX, REG_BIT, "b0", "b0", "bits", 0, 1, 0}, + {REG_BIT, B1_IDX, REG_BIT, "b1", "b1", "bits", 1, 1, 0}, + {REG_BIT, B2_IDX, REG_BIT, "b2", "b2", "bits", 2, 1, 0}, + {REG_BIT, B3_IDX, REG_BIT, "b3", "b3", "bits", 3, 1, 0}, + {REG_BIT, B4_IDX, REG_BIT, "b4", "b4", "bits", 4, 1, 0}, + {REG_BIT, B5_IDX, REG_BIT, "b5", "b5", "bits", 5, 1, 0}, + {REG_BIT, B6_IDX, REG_BIT, "b6", "b6", "bits", 6, 1, 0}, + {REG_BIT, B7_IDX, REG_BIT, "b7", "b7", "bits", 7, 1, 0}, {REG_GPR, X8_IDX, REG_GPR, "x8", "x8", "xreg", 0, 0, 0}, {REG_GPR, X9_IDX, REG_GPR, "x9", "x9", "xreg", 1, 0, 0}, {REG_GPR, X10_IDX, REG_GPR, "x10", "x10", "xreg", 2, 0, 0}, @@ -85,7 +94,10 @@ regs regs390[] = {0, A_IDX, 0, "a", "acc", "acc", 0, 0, 0}, {0, AP_IDX, 0, "ap", "ap", "ap", 0, 0, 0}, }; + int ds390_nRegs = 13; +int ds390_nBitRegs = 0; + static void spillThis (symbol *); static void freeAllRegs (); static iCode * packRegsDPTRuse (operand *); @@ -109,19 +121,17 @@ allocReg (short type) { regs390[i].isFree = 0; if (currFunc) - currFunc->regsUsed = - bitVectSetBit (currFunc->regsUsed, i); + currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, i); return ®s390[i]; } - /* other wise look for specific type + /* otherwise look for specific type of register */ if (regs390[i].isFree && regs390[i].type == type) { regs390[i].isFree = 0; if (currFunc) - currFunc->regsUsed = - bitVectSetBit (currFunc->regsUsed, i); + currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, i); return ®s390[i]; } } @@ -170,7 +180,6 @@ useReg (regs * reg) reg->isFree = 0; } - /*-----------------------------------------------------------------*/ /* nFreeRegs - returns number of free registers */ /*-----------------------------------------------------------------*/ @@ -202,8 +211,6 @@ nfreeRegsType (int type) return nFreeRegs (type); } - - /*-----------------------------------------------------------------*/ /* isOperandInReg - returns true if operand is currently in regs */ /*-----------------------------------------------------------------*/ @@ -242,6 +249,15 @@ computeSpillable (iCode * ic) } +/*-----------------------------------------------------------------*/ +/* bitType - will return 1 if the symbol has type REG_BIT */ +/*-----------------------------------------------------------------*/ +static int +bitType (symbol * sym, eBBlock * ebp, iCode * ic) +{ + return (sym->regType == REG_BIT ? 1 : 0); +} + /*-----------------------------------------------------------------*/ /* noSpilLoc - return true if a variable has no spil location */ /*-----------------------------------------------------------------*/ @@ -261,7 +277,7 @@ hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic) } /*-----------------------------------------------------------------*/ -/* directSpilLoc - will return 1 if the splilocation is in direct */ +/* directSpilLoc - will return 1 if the spillocation is in direct */ /*-----------------------------------------------------------------*/ static int directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic) @@ -364,7 +380,7 @@ leastUsedLR (set * sset) { /* if usage is the same then prefer - the spill the smaller of the two */ + to spill the smaller of the two */ if (lsym->used == sym->used) if (getSize (lsym->type) < getSize (sym->type)) sym = lsym; @@ -509,17 +525,23 @@ createStackSpil (symbol * sym) /* set the type to the spilling symbol */ sloc->type = copyLinkChain (sym->type); sloc->etype = getSpec (sloc->type); - if (options.model == MODEL_SMALL) { - SPEC_SCLS (sloc->etype) = S_DATA; - } else { - SPEC_SCLS (sloc->etype) = S_XDATA; - } + if (!IS_BIT (sloc->etype)) + { + if (options.model == MODEL_SMALL) + { + SPEC_SCLS (sloc->etype) = S_DATA; + } + else + { + SPEC_SCLS (sloc->etype) = S_XDATA; + } + } SPEC_EXTR (sloc->etype) = 0; SPEC_STAT (sloc->etype) = 0; SPEC_VOLATILE(sloc->etype) = 0; SPEC_ABSA(sloc->etype) = 0; - /* we don't allow it to be allocated` + /* we don't allow it to be allocated onto the external stack since : so we temporarily turn it off ; we also turn off memory model to prevent @@ -643,10 +665,20 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) /* get the spillable live ranges */ lrcs = computeSpillable (ic); - /* get all live ranges that are rematerizable */ - if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic))) + /* remove incompatible registers */ + if ((forSym->regType == REG_PTR) || (forSym->regType == REG_GPR)) { + selectS = liveRangesWith (lrcs, bitType, ebp, ic); + + for (sym = setFirstItem (selectS); sym; sym = setNextItem (selectS)) + { + bitVectUnSetBit (lrcs, sym->key); + } + } + /* get all live ranges that are rematerializable */ + if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic))) + { /* return the least used of these */ return leastUsedLR (selectS); } @@ -668,7 +700,6 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) /* if the symbol is local to the block then */ if (forSym->liveTo < ebp->lSeq) { - /* check if there are any live ranges allocated to registers that are not used in this block */ if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic))) @@ -705,7 +736,6 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) /* find live ranges with spillocation && not used as pointers */ if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic))) { - sym = leastUsedLR (selectS); /* mark this as allocation required */ sym->usl.spillLoc->allocreq++; @@ -715,7 +745,6 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) /* find live ranges with spillocation */ if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic))) { - sym = leastUsedLR (selectS); sym->usl.spillLoc->allocreq++; return sym; @@ -726,7 +755,6 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym) used ofcourse */ if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic))) { - /* return a created spil location */ sym = createStackSpil (leastUsedLR (selectS)); sym->usl.spillLoc->allocreq++; @@ -873,7 +901,22 @@ tryAgain: } /*-----------------------------------------------------------------*/ -/* getRegPtrNoSpil - get it cannot split */ +/* getRegBit - will try for Bit if not spill this */ +/*-----------------------------------------------------------------*/ +static regs *getRegBit (symbol * sym) +{ + regs *reg; + + /* try for a bit type */ + if ((reg = allocReg (REG_BIT))) + return reg; + + spillThis (sym); + return 0; +} + +/*-----------------------------------------------------------------*/ +/* getRegPtrNoSpil - get it cannot be spilt */ /*-----------------------------------------------------------------*/ static regs *getRegPtrNoSpil() { @@ -894,7 +937,7 @@ static regs *getRegPtrNoSpil() } /*-----------------------------------------------------------------*/ -/* getRegGprNoSpil - get it cannot split */ +/* getRegGprNoSpil - get it cannot be spilt */ /*-----------------------------------------------------------------*/ static regs *getRegGprNoSpil() { @@ -913,6 +956,27 @@ static regs *getRegGprNoSpil() return 0; } +/*-----------------------------------------------------------------*/ +/* getRegBitNoSpil - get it cannot be spilt */ +/*-----------------------------------------------------------------*/ +static regs *getRegBitNoSpil() +{ + regs *reg; + + /* try for a bit type */ + if ((reg = allocReg (REG_BIT))) + return reg; + + /* try for gpr type */ + if ((reg = allocReg (REG_GPR))) + return reg; + + assert(0); + + /* just to make the compiler happy */ + return 0; +} + /*-----------------------------------------------------------------*/ /* symHasReg - symbol has a given register */ /*-----------------------------------------------------------------*/ @@ -928,6 +992,29 @@ symHasReg (symbol * sym, regs * reg) return FALSE; } +/*-----------------------------------------------------------------*/ +/* updateRegUsage - update the registers in use at the start of */ +/* this icode */ +/*-----------------------------------------------------------------*/ +static void +updateRegUsage (iCode * ic) +{ + int reg; + + for (reg=0; regriu &= ~(1<riu |= (1<= B0_IDX); + } + } +} + /*-----------------------------------------------------------------*/ /* deassignLRs - check the live to and if they have registers & are */ /* not spilt then free up the registers */ @@ -1061,8 +1148,8 @@ reassignLR (operand * op) static int willCauseSpill (int nr, int rt) { - /* first check if there are any avlb registers - of te type required */ + /* first check if there are any available registers + of the type required */ if (rt == REG_PTR) { /* special case for pointer type @@ -1073,6 +1160,11 @@ willCauseSpill (int nr, int rt) if (nFreeRegs (REG_GPR) >= nr) return 0; } + else if (rt == REG_BIT) + { + if (nFreeRegs (rt) >= nr) + return 0; + } else { if (ds390_ptrRegReq) @@ -1217,7 +1309,7 @@ void reassignUnusedLRs (bitVect *unused) bitVectSetBit(_G.regAssigned,i) ; sym = hTabItemWithKey(liveRanges,i); - /* makr registers busy */ + /* make registers busy */ for (j = 0 ; j < sym->nRegs; j++) sym->regs[j]->isFree = 0; } @@ -1274,6 +1366,7 @@ serialRegAssign (eBBlock ** ebbs, int count) /* for all instructions do */ for (ic = ebbs[i]->sch; ic; ic = ic->next) { + updateRegUsage(ic); /* if this is an ipop that means some live range will have to be assigned again */ @@ -1308,7 +1401,7 @@ serialRegAssign (eBBlock ** ebbs, int count) int j; int ptrRegSet = 0; - /* Make sure any spill location is definately allocated */ + /* Make sure any spill location is definitely allocated */ if (sym->isspilt && !sym->remat && sym->usl.spillLoc && !sym->usl.spillLoc->allocreq) { @@ -1333,10 +1426,11 @@ serialRegAssign (eBBlock ** ebbs, int count) continue; } + willCS = willCauseSpill (sym->nRegs, sym->regType); /* if this is a bit variable then don't use precious registers along with expensive bit-to-char conversions but just spill it */ - if (SPEC_NOUN(sym->etype) == V_BIT) + if (willCS && SPEC_NOUN(sym->etype) == V_BIT) { spillThis (sym); continue; @@ -1346,15 +1440,11 @@ serialRegAssign (eBBlock ** ebbs, int count) a spill and there is nothing to spill or this one is rematerializable then spill this one */ - willCS = willCauseSpill (sym->nRegs, sym->regType); spillable = computeSpillable (ic); - if (sym->remat || - (willCS && bitVectIsZero (spillable))) + if (sym->remat || (willCS && bitVectIsZero (spillable))) { - spillThis (sym); continue; - } /* If the live range preceeds the point of definition @@ -1394,8 +1484,7 @@ serialRegAssign (eBBlock ** ebbs, int count) /* if we need ptr regs for the right side then mark it */ if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)) - && getSize (OP_SYMBOL (IC_LEFT (ic))->type) - <= (unsigned) PTRSIZE) + && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned) PTRSIZE) { ds390_ptrRegReq++; ptrRegSet = 1; @@ -1406,12 +1495,15 @@ serialRegAssign (eBBlock ** ebbs, int count) for (j = 0; j < sym->nRegs; j++) { + sym->regs[j] = NULL; if (sym->regType == REG_PTR) sym->regs[j] = getRegPtr (ic, ebbs[i], sym); + else if (sym->regType == REG_BIT) + sym->regs[j] = getRegBit (sym); else sym->regs[j] = getRegGpr (ic, ebbs[i], sym); - /* if the allocation falied which means + /* if the allocation failed which means this was spilt then break */ if (!sym->regs[j]) break; @@ -1540,7 +1632,7 @@ static void fillGaps() } } - /* look for livernages that was spilt by the allocator */ + /* look for liveranges that were spilt by the allocator */ for (sym = hTabFirstItem(liveRanges,&key) ; sym ; sym = hTabNextItem(liveRanges,&key)) { @@ -1654,6 +1746,33 @@ static void fillGaps() } } +/*-----------------------------------------------------------------*/ +/* findAllBitregs :- returns bit vector of all bit registers */ +/*-----------------------------------------------------------------*/ +static bitVect * +findAllBitregs (void) +{ + bitVect *rmask = newBitVect (ds390_nRegs); + int j; + + for (j = 0; j < ds390_nRegs; j++) + { + if (regs390[j].type == REG_BIT) + rmask = bitVectSetBit (rmask, regs390[j].rIdx); + } + + return rmask; +} + +/*-----------------------------------------------------------------*/ +/* ds390_allBitregs :- returns bit vector of all bit registers */ +/*-----------------------------------------------------------------*/ +bitVect * +ds390_allBitregs (void) +{ + return _G.allBitregs; +} + /*-----------------------------------------------------------------*/ /* rUmaskForOp :- returns register mask for an operand */ /*-----------------------------------------------------------------*/ @@ -1918,13 +2037,12 @@ regTypeNum () } /* determine the type of register required */ - if (sym->nRegs == 1 && - IS_PTR (sym->type) && - sym->uptr) + if (sym->nRegs == 1 && IS_PTR (sym->type) && sym->uptr) sym->regType = REG_PTR; + else if (IS_BIT(sym->type)) + sym->regType = REG_BIT; else sym->regType = REG_GPR; - } else /* for the first run we don't provide */ @@ -1945,6 +2063,9 @@ freeAllRegs () for (i = 0; i < ds390_nRegs; i++) regs390[i].isFree = 1; + + for (i = B0_IDX; i < ds390_nBitRegs; i++) + regs390[i].isFree = 1; } /*-----------------------------------------------------------------*/ @@ -2211,8 +2332,7 @@ findAssignToSym (operand * op, iCode * ic) if (!IS_SYMOP (IC_RIGHT (dic))) return NULL; - /* if the symbol is in far space then - we should not */ + /* if the symbol is in far space then we should not */ if (isOperandInFarSpace (IC_RIGHT (dic))) return NULL; @@ -2703,7 +2823,7 @@ packRegsForAccUse (iCode * ic) return; /* if used in ^ operation then make sure right is not a - literl */ + literal */ if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic))) return; @@ -2762,13 +2882,14 @@ accuse: } /*-----------------------------------------------------------------*/ -/* packForPush - hueristics to reduce iCode for pushing */ +/* packForPush - heuristics to reduce iCode for pushing */ /*-----------------------------------------------------------------*/ static void -packForPush (iCode * ic, eBBlock * ebp) +packForPush (iCode * ic, eBBlock ** ebpp, int blockno) { iCode *dic, *lic; bitVect *dbv; + struct eBBlock * ebp = ebpp[blockno]; if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic))) return; @@ -2792,7 +2913,8 @@ packForPush (iCode * ic, eBBlock * ebp) inbetween */ dbv = OP_DEFS(IC_RIGHT(dic)); for (lic = ic; lic && lic != dic ; lic = lic->prev) { - if (bitVectBitValue(dbv,lic->key)) return ; + if (bitVectBitValue (dbv, lic->key)) + return; } /* make sure they have the same type */ if (IS_SPEC(operandType(IC_LEFT(ic)))) @@ -2831,14 +2953,14 @@ packForPush (iCode * ic, eBBlock * ebp) /* pressure */ /*-----------------------------------------------------------------*/ static void -packRegisters (eBBlock * ebp) +packRegisters (eBBlock ** ebpp, int blockno) { iCode *ic; int change = 0; + eBBlock *ebp = ebpp[blockno]; while (1) { - change = 0; /* look for assignments of the form */ @@ -2858,6 +2980,48 @@ packRegisters (eBBlock * ebp) for (ic = ebp->sch; ic; ic = ic->next) { + /* Fix for bug #979599: */ + /* P0 &= ~1; */ + + /* Look for two subsequent iCodes with */ + /* iTemp := _c; */ + /* _c = iTemp & op; */ + /* and replace them by */ + /* iTemp := _c; */ + /* _c = _c & op; */ + if ((ic->op == BITWISEAND || ic->op == '|' || ic->op == '^') && + ic->prev && + ic->prev->op == '=' && + IS_ITEMP (IC_LEFT (ic)) && + IC_LEFT (ic) == IC_RESULT (ic->prev) && + isOperandEqual (IC_RESULT(ic), IC_RIGHT(ic->prev))) + { + iCode* ic_prev = ic->prev; + symbol* prev_result_sym = OP_SYMBOL (IC_RESULT (ic_prev)); + + ReplaceOpWithCheaperOp (&IC_LEFT (ic), IC_RESULT (ic)); + if (IC_RESULT (ic_prev) != IC_RIGHT (ic)) + { + bitVectUnSetBit (OP_USES (IC_RESULT (ic_prev)), ic->key); + if (/*IS_ITEMP (IC_RESULT (ic_prev)) && */ + prev_result_sym->liveTo == ic->seq) + { + prev_result_sym->liveTo = ic_prev->seq; + } + } + bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key); + + bitVectSetBit (ic->rlive, IC_RESULT (ic)->key); + + if (bitVectIsZero (OP_USES (IC_RESULT (ic_prev)))) + { + bitVectUnSetBit (ic->rlive, IC_RESULT (ic)->key); + bitVectUnSetBit (OP_DEFS (IC_RESULT (ic_prev)), ic_prev->key); + remiCodeFromeBBlock (ebp, ic_prev); + hTabDeleteItem (&iCodehTab, ic_prev->key, ic_prev, DELETE_ITEM, NULL); + } + } + /* if this is an itemp & result of an address of a true sym then mark this as rematerialisable */ if (ic->op == ADDRESS_OF && @@ -2894,7 +3058,6 @@ packRegisters (eBBlock * ebp) !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) && bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1) { - OP_SYMBOL (IC_RESULT (ic))->remat = OP_SYMBOL (IC_RIGHT (ic))->remat; OP_SYMBOL (IC_RESULT (ic))->rematiCode = @@ -2906,10 +3069,12 @@ packRegisters (eBBlock * ebp) if (ic->op == CAST && IS_SYMOP(IC_RIGHT(ic)) && !OP_SYMBOL(IC_RESULT(ic))->isreqv && - OP_SYMBOL(IC_RIGHT(ic))->remat ) { - sym_link *to_type = operandType(IC_LEFT(ic)); - sym_link *from_type = operandType(IC_RIGHT(ic)); - if (IS_GENPTR(to_type) && IS_PTR(from_type)) { + OP_SYMBOL(IC_RIGHT(ic))->remat ) + { + sym_link *to_type = operandType(IC_LEFT(ic)); + sym_link *from_type = operandType(IC_RIGHT(ic)); + if (IS_GENPTR(to_type) && IS_PTR(from_type)) + { OP_SYMBOL (IC_RESULT (ic))->remat = 1; OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic; OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL; @@ -3045,8 +3210,8 @@ packRegisters (eBBlock * ebp) packRegsDPTRuse (IC_LEFT (ic)); } - /* if this is cast for intergral promotion then - check if only use of the definition of the + /* if this is a cast for intergral promotion then + check if it's the only use of the definition of the operand being casted/ if yes then replace the result of that arithmetic operation with this result and get rid of the cast */ @@ -3108,7 +3273,7 @@ packRegisters (eBBlock * ebp) */ if (ic->op == IPUSH || ic->op == SEND) { - packForPush (ic, ebp); + packForPush (ic, ebpp, blockno); } @@ -3130,7 +3295,6 @@ packRegisters (eBBlock * ebp) getSize (operandType (IC_RESULT (ic))) <= 2) packRegsForAccUse (ic); - } } @@ -3150,12 +3314,23 @@ ds390_assignRegisters (ebbIndex * ebbi) setToNull ((void *) &_G.totRegAssigned); setToNull ((void *) &_G.funcrUsed); ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0; - ds390_nRegs = 12; - if (options.model != MODEL_FLAT24) options.stack10bit = 0; + if ((currFunc && IFFUNC_ISREENT (currFunc->type)) || options.stackAuto) + { + ds390_nBitRegs = 8; + } + else + { + ds390_nBitRegs = 0; + } + ds390_nRegs = 12 + ds390_nBitRegs; + _G.allBitregs = findAllBitregs (); + + if (options.model != MODEL_FLAT24) + options.stack10bit = 0; /* change assignments this will remove some live ranges reducing some register pressure */ for (i = 0; i < count; i++) - packRegisters (ebbs[i]); + packRegisters (ebbs, i); /* liveranges probably changed by register packing so we compute them again */ @@ -3174,7 +3349,7 @@ ds390_assignRegisters (ebbIndex * ebbi) ds390_nRegs = 8; freeAllRegs (); fillGaps(); - ds390_nRegs = 12; + ds390_nRegs = 12 + ds390_nBitRegs; /* if stack was extended then tell the user */ if (_G.stackExtend) @@ -3207,7 +3382,8 @@ ds390_assignRegisters (ebbIndex * ebbi) currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX); } - if (options.dump_rassgn) { + if (options.dump_rassgn) + { dumpEbbsToFileExt (DUMP_RASSGN, ebbi); dumpLiveRanges (DUMP_LRANGE, liveRanges); } diff --git a/src/ds390/ralloc.h b/src/ds390/ralloc.h index ff7edb42..27a8d920 100644 --- a/src/ds390/ralloc.h +++ b/src/ds390/ralloc.h @@ -29,12 +29,13 @@ enum { - R2_IDX = 0, R3_IDX, R4_IDX, - R5_IDX, R6_IDX, R7_IDX, - R0_IDX, R1_IDX, DPL_IDX, - DPH_IDX, DPX_IDX, B_IDX, X8_IDX, - X9_IDX, X10_IDX, X11_IDX, - X12_IDX, CND_IDX , + R2_IDX = 0, R3_IDX, R4_IDX, R5_IDX, + R6_IDX, R7_IDX, R0_IDX, R1_IDX, + DPL_IDX, DPH_IDX, DPX_IDX, B_IDX, + B0_IDX, B1_IDX, B2_IDX, B3_IDX, + B4_IDX, B5_IDX, B6_IDX, B7_IDX, + X8_IDX, X9_IDX, X10_IDX, X11_IDX, + X12_IDX, CND_IDX, A_IDX, DPL1_IDX, DPH1_IDX, DPX1_IDX, DPS_IDX, AP_IDX, END_IDX @@ -44,6 +45,7 @@ enum #define REG_PTR 0x01 #define REG_GPR 0x02 #define REG_CND 0x04 +#define REG_BIT 0x08 /* definition for the registers */ typedef struct regs { @@ -64,8 +66,10 @@ extern regs regs390[]; regs *ds390_regWithIdx (int); bitVect *ds390_rUmaskForOp (operand * op); +bitVect *ds390_allBitregs (void); extern int ds390_ptrRegReq; extern int ds390_nRegs; +extern int ds390_nBitRegs; #endif diff --git a/support/regression/tests/sfr16.c b/support/regression/tests/sfr16.c index 669f805e..0c345b19 100644 --- a/support/regression/tests/sfr16.c +++ b/support/regression/tests/sfr16.c @@ -5,34 +5,38 @@ #include #if defined (SDCC_mcs51) -sfr at 0x8A TL0; //timer 0 low byte -sfr at 0x8C TH0; //timer 0 high byte - -sfr16 at 0x8C8A TMR0; //timer 0 -sfr32 at 0x8C8ACDCC TIMERS; //timer 0 & 2 + sfr at 0x8A SFR_LSB; //timer 0 low byte + sfr at 0x8C SFR_MSB; //timer 0 high byte + sfr16 at 0x8C8A SFR_16; //timer 0 + sfr32 at 0x8C8ACDCC SFR_32; //timer 0 & 2 +#elif defined (SDCC_ds390) + sfr at 0x8B SFR_LSB; //timer 1 low byte + sfr at 0x8D SFR_MSB; //timer 1 high byte + sfr16 at 0x8D8B SFR_16; //timer 1 + sfr32 at 0x8D8BCDCC SFR_32; //timer 1 & 2 #endif void test_sfr(void) { -#if defined (SDCC_mcs51) - TMR0 = 0x00FE; - ASSERT (TH0 == 0x00); - ASSERT (TL0 == 0xFE); +#if defined (SFR_16) + SFR_16 = 0x00FE; + ASSERT (SFR_MSB == 0x00); + ASSERT (SFR_LSB == 0xFE); - TMR0++; - ASSERT (TH0 == 0x00); - ASSERT (TL0 == 0xFF); + SFR_16++; + ASSERT (SFR_MSB == 0x00); + ASSERT (SFR_LSB == 0xFF); - TMR0++; - ASSERT (TH0 == 0x01); - ASSERT (TL0 == 0x00); + SFR_16++; + ASSERT (SFR_MSB == 0x01); + ASSERT (SFR_LSB == 0x00); - TL0++; - ASSERT (TMR0 == 0x0101); + SFR_LSB++; + ASSERT (SFR_16 == 0x0101); - TIMERS = 0x12345678; - TIMERS -= 0x02040608; - ASSERT (TIMERS == 0x10305070); + SFR_32 = 0x12345678; + SFR_32 -= 0x02040608; + ASSERT (SFR_32 == 0x10305070); #endif }