#include <stdlib.h>
#include <string.h>
#include <ctype.h>
-#include "SDCCglobl.h"
+
+#include <common.h>
+#include "ralloc.h"
+#include "gen.h"
#ifdef HAVE_SYS_ISA_DEFS_H
#include <sys/isa_defs.h>
#endif
#endif
-#include "common.h"
-#include "SDCCpeeph.h"
-#include "ralloc.h"
-#include "gen.h"
-
char *aopLiteral (value *val, int offset);
+#if 0
+//REMOVE ME!!!
extern int allocInfo;
+#endif
/* this is the down and dirty file with all kinds of
kludgy & hacky stuff. This is what it is all about
set *sendSet;
} _G;
-extern int ds390_ptrRegReq ;
-extern int ds390_nRegs;
-extern FILE *codeOutFile;
static void saverbank (int, iCode *,bool);
+
#define RESULTONSTACK(x) \
(IC_RESULT(x) && IC_RESULT(x)->aop && \
IC_RESULT(x)->aop->type == AOP_STK )
return aop;
}
-/* #define DPS_OPT */ /* turn this on after some more testing. */
+/* Turn this off if the world goes to hell. */
+#define LAZY_DPS_OPT
-static int _currentDPS;
-static int _desiredDPS;
-static int _lazyDPS = 0;
+static int _currentDPS; /* Current processor DPS. */
+static int _desiredDPS; /* DPS value compiler thinks we should be using. */
+static int _lazyDPS = 0; /* if non-zero, we are doing lazy evaluation of DPS changes. */
+/*-----------------------------------------------------------------*/
+/* genSetDPTR: generate code to select which DPTR is in use (zero */
+/* selects standard DPTR (DPL/DPH/DPX), non-zero selects DS390 */
+/* alternate DPTR (DPL1/DPH1/DPX1). */
+/*-----------------------------------------------------------------*/
static void genSetDPTR(int n)
{
-#ifdef DPS_OPT
+
+#ifdef LAZY_DPS_OPT
+ /* If we are doing lazy evaluation, simply note the desired
+ * change, but don't emit any code yet.
+ */
if (_lazyDPS)
{
_desiredDPS = n;
- /* emitcode(";", "_desiredDPS = %d", n); */
return;
}
#endif
}
}
-static void _startAopGetLoop(void)
+/*-----------------------------------------------------------------*/
+/* _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. */
+/*-----------------------------------------------------------------*/
+static void _startLazyDPSEvaluation(void)
{
_currentDPS = 0;
_desiredDPS = 0;
_lazyDPS = 1;
}
-static void _endAopGetLoop(void)
-{
- _lazyDPS = 0;
- if (_currentDPS)
- {
- genSetDPTR(0);
- }
- _currentDPS = 0;
- _desiredDPS = 0;
-}
-
-static void _aopFlushDPS(void)
+/*-----------------------------------------------------------------*/
+/* _flushLazyDPS: emit code to force the actual DPS setting to the */
+/* desired one. Call before using DPTR within a lazy DPS evaluation*/
+/* block. */
+/*-----------------------------------------------------------------*/
+static void _flushLazyDPS(void)
{
if (!_lazyDPS)
{
+ /* nothing to do. */
return;
}
+
if (_desiredDPS != _currentDPS)
{
if (_desiredDPS)
emitcode("dec", "dps");
}
_currentDPS = _desiredDPS;
- /* emitcode(";", "_currentDPS = _desiredDPS = %d", _currentDPS); */
}
}
+/*-----------------------------------------------------------------*/
+/* _endLazyDPSEvaluation: end lazy DPS evaluation block. */
+/* */
+/* Forces us back to the safe state (standard DPTR selected). */
+/*-----------------------------------------------------------------*/
+static void _endLazyDPSEvaluation(void)
+{
+ if (_currentDPS)
+ {
+ genSetDPTR(0);
+ _flushLazyDPS();
+ }
+ _lazyDPS = 0;
+ _currentDPS = 0;
+ _desiredDPS = 0;
+}
+
+
+
/*-----------------------------------------------------------------*/
/* pointerCode - returns the code for a pointer type */
/*-----------------------------------------------------------------*/
if (useDP2)
{
genSetDPTR(1);
- _aopFlushDPS();
+ _flushLazyDPS();
emitcode ("mov","dptr,#%s", sym->rname);
genSetDPTR(0);
}
if (sym->ruonly ) {
int i;
+
+ if (useDP2)
+ {
+ /* a AOP_STR uses DPTR, but DPTR is already in use;
+ * we're just hosed.
+ */
+ fprintf(stderr, "*** Internal error: AOP_STR with DPTR in use!\n");
+ }
+
aop = op->aop = sym->aop = newAsmop(AOP_STR);
aop->size = getSize(sym->type);
for ( i = 0 ; i < fReturnSize_390 ; i++ )
}
}
- _aopFlushDPS();
+ _flushLazyDPS();
while (offset > aop->coff) {
emitcode ("inc","dptr");
{
genSetDPTR(1);
}
- _aopFlushDPS();
+ _flushLazyDPS();
if (aop->code) {
werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
}
-#if 0
-/*-----------------------------------------------------------------*/
-/* pointToEnd :- points to the last byte of the operand */
-/*-----------------------------------------------------------------*/
-static void pointToEnd (asmop *aop)
-{
- int count ;
- if (!aop)
- return ;
-
- aop->coff = count = (aop->size - 1);
- switch (aop->type) {
- case AOP_R0 :
- case AOP_R1 :
- while (count--)
- emitcode("inc","%s",aop->aopu.aop_ptr->name);
- break;
- case AOP_DPTR :
- while (count--)
- emitcode("inc","dptr");
- break;
- }
-
-}
-#endif
-
/*-----------------------------------------------------------------*/
/* reAdjustPreg - points a register back to where it should */
/*-----------------------------------------------------------------*/
if (aop->type == AOP_DPTR2)
{
genSetDPTR(1);
- _aopFlushDPS();
+ _flushLazyDPS();
}
while (size--)
{
size = AOP_SIZE(op) - 1;
offset = 1;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
l = aopGet(op->aop,offset++,FALSE,FALSE,TRUE);
MOVA(l);
aopGet(op->aop,
offset++,FALSE,FALSE,FALSE));
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
tlbl = newiTempLabel(NULL);
tlbl = newiTempLabel(NULL);
size--;
}
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
if (AOP_NEEDSACC(oper))
{
emitcode("push", "b");
emitcode("orl","a,%s",aopGet(AOP(oper),offset++,FALSE,FALSE,FALSE));
}
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
if (AOP_NEEDSACC(oper))
{
}
size = AOP_SIZE(IC_RESULT(ic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE);
MOVA(l);
emitcode("cpl","a");
aopPut(AOP(IC_RESULT(ic)),"a",offset++);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
release:
first it then copy the rest in place */
D(emitcode(";", "genUminusFloat"););
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
size = AOP_SIZE(op) - 1;
l = aopGet(AOP(op),3,FALSE,FALSE,TRUE);
MOVA(l);
offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
/*-----------------------------------------------------------------*/
/* otherwise subtract from zero */
size = AOP_SIZE(IC_LEFT(ic));
offset = 0 ;
- //CLRC ;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while(size--) {
char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE);
if (!strcmp(l,"a")) {
}
aopPut(AOP(IC_RESULT(ic)),"a",offset++);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
/* if any remaining bytes in the result */
/* we just need to propagate the sign */
static void pushSide(operand * oper, int size)
{
int offset = 0;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
char *l = aopGet(AOP(oper),offset++,FALSE,TRUE,FALSE);
if (AOP_TYPE(oper) != AOP_REG &&
} else
emitcode("push","%s",l);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
/*-----------------------------------------------------------------*/
{
int offset = 0;
int size = AOP_SIZE(oper);
+
+ _startLazyDPSEvaluation();
while (size--) {
aopPut(AOP(oper),fReturn[offset],offset);
offset++;
}
+ _endLazyDPSEvaluation();
}
emitcode("mov","%s,_spx",r->name);
size = AOP_SIZE(IC_LEFT(ic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while(size--) {
char *l = aopGet(AOP(IC_LEFT(ic)),
emitcode("inc","%s",r->name);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
emitcode("mov","_spx,%s",r->name);
aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
size = AOP_SIZE(IC_LEFT(ic));
/* push it on the stack */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while(size--) {
l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE,TRUE);
if (*l == '#') {
}
emitcode("push","%s",l);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
return ;
}
/* then do the push */
aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
-
- // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
+ // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
size = AOP_SIZE(IC_LEFT(ic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE,FALSE);
if (AOP_TYPE(IC_LEFT(ic)) != AOP_REG &&
} else
emitcode("push","%s",l);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
}
aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
size = AOP_SIZE(IC_LEFT(ic));
offset = (size-1);
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--)
{
emitcode("pop","%s",aopGet(AOP(IC_LEFT(ic)),offset--,
FALSE,TRUE,TRUE));
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
}
aopOp(IC_LEFT(sic),sic,FALSE, TRUE);
size = AOP_SIZE(IC_LEFT(sic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
char *l = aopGet(AOP(IC_LEFT(sic)),offset,
FALSE, FALSE, TRUE);
l);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
}
_G.sendSet = NULL;
OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
+#ifdef LAZY_DPS_OPT
+ /* Not really related to LAZY_DPS_OPT, but don't want
+ * another testing flag right now...
+ */
+#define FAR_RETURN_OPT
+#ifdef FAR_RETURN_OPT
+ if (isOperandInFarSpace(IC_RESULT(ic))
+ && getSize(operandType(IC_RESULT(ic))) <= 2)
+ {
+ int size = getSize(operandType(IC_RESULT(ic)));
+
+ /* Special case for 1 or 2 byte return in far space. */
+ emitcode(";", "Kevin function call abuse #1");
+
+ MOVA(fReturn[0]);
+ if (size > 1)
+ {
+ emitcode("mov", "b,%s", fReturn[1]);
+ }
+
+ aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+
+ if (size > 1)
+ {
+ aopPut(AOP(IC_RESULT(ic)),"b",1);
+ }
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ }
+ else
+#endif
+ {
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE, TRUE);
+ _G.accInUse--;
+
+ assignResultValue(IC_RESULT(ic));
+
+ freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
+ }
+#else
if (!isOperandInFarSpace(IC_RESULT(ic)))
{
- _G.accInUse++;
+ _G.accInUse++;
aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
- _G.accInUse--;
+ _G.accInUse--;
- assignResultValue(IC_RESULT(ic));
+ assignResultValue(IC_RESULT(ic));
- freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
- }
+ freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
+ }
else
{
/* Result is in far space, and requires DPTR to access
aopPut(AOP(IC_RESULT(ic)),"a",++offset);
}
freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
- }
+ }
+#endif
}
/* adjust the stack for parameters if
aopOp(IC_LEFT(sic),sic,FALSE, FALSE);
size = AOP_SIZE(IC_LEFT(sic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--)
{
char *l = aopGet(AOP(IC_LEFT(sic)),offset,
}
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
}
_G.sendSet = NULL;
aopOp(IC_LEFT(ic),ic,FALSE, TRUE);
size = AOP_SIZE(IC_LEFT(ic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
char *l ;
if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) {
emitcode("mov","%s,%s",fReturn[offset++],l);
}
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
if (pushed) {
while(pushed) {
aopPut(AOP(IC_RESULT(ic)),"a",0);
} else {
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (icount--)
{
emitcode ("inc","%s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE,FALSE));
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
return TRUE ;
/* special cases :- */
+#ifdef LAZY_DPS_OPT
+ aopOp (IC_RIGHT(ic),ic,FALSE, FALSE);
+ aopOp (IC_LEFT(ic),ic,FALSE,
+ (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR));
+#else
aopOp (IC_LEFT(ic),ic,FALSE, TRUE);
aopOp (IC_RIGHT(ic),ic,FALSE, FALSE);
+#endif
if ((AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2) &&
(AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR))
{
}
else
{
- aopOp (IC_RESULT(ic),ic,TRUE, AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR);
+ aopOp (IC_RESULT(ic),ic,TRUE,
+ ((AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)
+ || (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR)));
/* if literal, literal on the right or
if left requires ACC or right is already
outBitC(IC_RESULT(ic));
} else {
size = getDataSize(IC_RESULT(ic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE,TRUE));
emitcode("addc","a,#00");
aopPut(AOP(IC_RESULT(ic)),"a",offset++);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
goto release ;
}
}
size = getDataSize(pushResult ? IC_LEFT(ic) : IC_RESULT(ic));
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while(size--)
{
if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC)
}
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
if (pushResult)
{
}
}
+ _startLazyDPSEvaluation();
while(size--)
{
emitcode("pop", "acc");
aopPut(AOP(IC_RESULT(ic)), "a", --offset);
}
+ _endLazyDPSEvaluation();
}
adjustArithmeticResult(ic);
AOP_TYPE(IC_RESULT(ic)) == AOP_REG &&
sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (icount--)
{
emitcode ("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
return TRUE ;
}
/* if literal, add a,#-lit, else normal subb */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE));
if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
}
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
if (pushResult)
{
AOP_OP_3(ic);
AOP_SET_LOCALS(ic);
- #if 0
+#if 0
aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
aopOp((right= IC_RIGHT(ic)),ic,FALSE, TRUE);
aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
- #endif
+#endif
#ifdef DEBUG_TYPE
emitcode("","; Type res[%d] = l[%d]&r[%d]",
offset = size - 1 ;
CLRC;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(left),offset,FALSE,FALSE,TRUE);
MOVA(l);
if (AOP_SIZE(result) > 1)
aopPut(AOP(result),"a",offset--);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
/* now we need to put the carry into the
highest order byte of the result */
aopPut(AOP(result),"a",offset++);
}
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(left),offset,FALSE,FALSE,TRUE);
MOVA(l);
if (AOP_SIZE(result) > 1)
aopPut(AOP(result),"a",offset++);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
/* now we need to put the carry into the
highest order byte of the result */
}
}
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccSRsh - signed right shift accumulator by known count */
/*-----------------------------------------------------------------*/
}
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftR1Left2Result - shift right one byte from left to result */
/*-----------------------------------------------------------------*/
AccRsh(shCount);
aopPut(AOP(result),"a",offr);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftL1Left2Result - shift left one byte from left to result */
/*-----------------------------------------------------------------*/
AccLsh(shCount);
aopPut(AOP(result),"a",offr);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* movLeft2Result - move byte from left to result */
/*-----------------------------------------------------------------*/
}
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccAXRrl1 - right rotate c->a:x->c by 1 */
/*-----------------------------------------------------------------*/
emitcode("rrc","a");
emitcode("xch","a,%s", x);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccAXLrl1 - left rotate c<-a:x<-c by 1 */
/*-----------------------------------------------------------------*/
emitcode("xch","a,%s",x);
emitcode("rlc","a");
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccAXLsh1 - left shift a:x<-0 by 1 */
/*-----------------------------------------------------------------*/
emitcode("xch","a,%s",x);
emitcode("rlc","a");
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccAXLsh - left shift a:x by known count (0..7) */
/*-----------------------------------------------------------------*/
break;
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccAXRsh - right shift a:x known count (0..7) */
/*-----------------------------------------------------------------*/
break;
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* AccAXRshS - right shift signed a:x known count (0..7) */
/*-----------------------------------------------------------------*/
break;
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftL2Left2Result - shift left two bytes from left to result */
/*-----------------------------------------------------------------*/
AccAXLsh( aopGet(AOP(result),offr,FALSE,FALSE,FALSE), shCount);
aopPut(AOP(result),"a",offr+MSB16);
}
+#endif
-
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftR2Left2Result - shift right two bytes from left to result */
/*-----------------------------------------------------------------*/
if(getDataSize(result) > 1)
aopPut(AOP(result),"a",offr+MSB16);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftLLeftOrResult - shift left one byte from left, or to result*/
/*-----------------------------------------------------------------*/
/* back to result */
aopPut(AOP(result),"a",offr);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftRLeftOrResult - shift right one byte from left,or to result*/
/*-----------------------------------------------------------------*/
/* back to result */
aopPut(AOP(result),"a",offr);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genlshOne - left shift a one byte quantity by known count */
/*-----------------------------------------------------------------*/
D(emitcode(";", "genlshOne "););
shiftL1Left2Result(left, LSB, result, LSB, shCount);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genlshTwo - left shift two bytes by known amount != 0 */
/*-----------------------------------------------------------------*/
shiftL2Left2Result(left, LSB, result, LSB, shCount);
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftLLong - shift left one long from left to result */
/* offl = LSB or MSB16 */
if(offr != LSB)
aopPut(AOP(result),zero,LSB);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genlshFour - shift four byte by a known amount != 0 */
/*-----------------------------------------------------------------*/
shiftL2Left2Result(left, LSB, result, LSB, shCount);
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genLeftShiftLiteral - left shifting by known count */
/*-----------------------------------------------------------------*/
freeAsmop(left,NULL,ic,TRUE);
freeAsmop(result,NULL,ic,TRUE);
}
+#endif
/*-----------------------------------------------------------------*/
/* genLeftShift - generates code for left shifting */
aopOp(right,ic,FALSE, FALSE);
- #if 0
+#if 0
/* if the shift count is known then do it
as efficiently as possible */
if (AOP_TYPE(right) == AOP_LIT) {
genLeftShiftLiteral (left,right,result,ic);
return ;
}
- #endif
+#endif
/* shift count is unknown then we have to form
a loop get the loop count in B : Note: we take
size = AOP_SIZE(result);
offset=0;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(left),offset,FALSE,TRUE,FALSE);
if (*l == '@' && (IS_AOP_PREG(result))) {
aopPut(AOP(result),l,offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
tlbl = newiTempLabel(NULL);
MOVA(l);
emitcode("add","a,acc");
aopPut(AOP(result),"a",offset++);
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (--size) {
l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
MOVA(l);
emitcode("rlc","a");
aopPut(AOP(result),"a",offset++);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
reAdjustPreg(AOP(result));
emitcode("","%05d$:",tlbl1->key+100);
freeAsmop(result,NULL,ic,TRUE);
}
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genrshOne - right shift a one byte quantity by known count */
/*-----------------------------------------------------------------*/
D(emitcode(";", "genrshOne"););
shiftR1Left2Result(left, LSB, result, LSB, shCount, sign);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genrshTwo - right shift two bytes by known amount != 0 */
/*-----------------------------------------------------------------*/
else
shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* shiftRLong - shift right one long from left to result */
/* offl = LSB or MSB16 */
aopPut(AOP(result),"a",LSB);
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genrshFour - shift four byte by a known amount != 0 */
/*-----------------------------------------------------------------*/
}
}
}
+#endif
+#if 0
+//REMOVE ME!!!
/*-----------------------------------------------------------------*/
/* genRightShiftLiteral - right shifting by known count */
/*-----------------------------------------------------------------*/
freeAsmop(result,NULL,ic,TRUE);
}
}
+#endif
/*-----------------------------------------------------------------*/
/* genSignedRightShift - right shift of signed number */
aopOp(right,ic,FALSE, FALSE);
- #if 0
+#if 0
if ( AOP_TYPE(right) == AOP_LIT) {
genRightShiftLiteral (left,right,result,ic,1);
return ;
}
- #endif
- /* shift count is unknown then we have to form
+#endif
+ /* shift count is unknown then we have to form
a loop get the loop count in B : Note: we take
only the lower order byte since shifting
more that 32 bits make no sense anyway, ( the
size = AOP_SIZE(result);
offset=0;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(left),offset,FALSE,TRUE,FALSE);
if (*l == '@' && IS_AOP_PREG(result)) {
aopPut(AOP(result),l,offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
/* mov the highest order bit to OVR */
emitcode("sjmp","%05d$",tlbl1->key+100);
emitcode("","%05d$:",tlbl->key+100);
emitcode("mov","c,ov");
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
MOVA(l);
emitcode("rrc","a");
aopPut(AOP(result),"a",offset--);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
reAdjustPreg(AOP(result));
emitcode("","%05d$:",tlbl1->key+100);
emitcode("djnz","b,%05d$",tlbl->key+100);
aopOp(right,ic,FALSE, FALSE);
- #if 0
+#if 0
/* if the shift count is known then do it
as efficiently as possible */
if (AOP_TYPE(right) == AOP_LIT) {
genRightShiftLiteral (left,right,result,ic, 0);
return ;
}
- #endif
+#endif
/* shift count is unknown then we have to form
a loop get the loop count in B : Note: we take
size = AOP_SIZE(result);
offset=0;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(left),offset,FALSE,TRUE,FALSE);
if (*l == '@' && IS_AOP_PREG(result)) {
aopPut(AOP(result),l,offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
tlbl = newiTempLabel(NULL);
emitcode("sjmp","%05d$",tlbl1->key+100);
emitcode("","%05d$:",tlbl->key+100);
CLRC;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
MOVA(l);
emitcode("rrc","a");
aopPut(AOP(result),"a",offset--);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
reAdjustPreg(AOP(result));
emitcode("","%05d$:",tlbl1->key+100);
/* get the string representation of the name */
l = aopGet(AOP(left),0,FALSE,TRUE,FALSE);
size = AOP_SIZE(result);
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
if (offset)
sprintf(buffer,"(%s + %d)",l+1,offset);
sprintf(buffer,"%s",l+1);
aopPut(AOP(result),buffer,offset++);
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
freeAsmop(left,NULL,ic,TRUE);
freeAsmop(result,NULL,ic,TRUE);
else
{
/* we need to get it byte by byte */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
if (AOP_TYPE(left) != AOP_DPTR)
{
emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
emitcode("pop", "dph");
emitcode("pop", "dpl");
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
}
/* so dptr know contains the address */
size = AOP_SIZE(result);
offset = 0 ;
+ _startLazyDPSEvaluation();
while (size--) {
+
+ genSetDPTR(0);
+ _flushLazyDPS();
+
emitcode("movx","a,@dptr");
- aopPut(AOP(result),"a",offset++);
if (size)
- emitcode("inc","dptr");
+ emitcode("inc","dptr");
+
+ aopPut(AOP(result),"a",offset++);
}
+ _endLazyDPSEvaluation();
}
freeAsmop(result,NULL,ic,TRUE);
if (AOP_TYPE(left) == AOP_IMMD)
emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE,FALSE));
else { /* we need to get it byte by byte */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
emitcode("mov","dpx,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
}
/* so dptr know contains the address */
freeAsmop(left,NULL,ic,TRUE);
- aopOp(result,ic,FALSE, FALSE);
+ aopOp(result,ic,FALSE, TRUE);
/* if bit then unpack */
if (IS_BITVAR(retype))
size = AOP_SIZE(result);
offset = 0 ;
- while (size--) {
+ _startLazyDPSEvaluation();
+ while (size--)
+ {
+ genSetDPTR(0);
+ _flushLazyDPS();
+
emitcode("clr","a");
emitcode("movc","a,@a+dptr");
- aopPut(AOP(result),"a",offset++);
if (size)
- emitcode("inc","dptr");
+ emitcode("inc","dptr");
+ aopPut(AOP(result),"a",offset++);
}
+ _endLazyDPSEvaluation();
}
freeAsmop(result,NULL,ic,TRUE);
emitcode("mov","b,#%d",pointerCode(retype));
}
else { /* we need to get it byte by byte */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
if (options.model == MODEL_FLAT24)
{
emitcode("mov","b,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
}
/* so dptr know contains the address */
else
{
/* we need to get it byte by byte */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
if (AOP_TYPE(result) != AOP_DPTR)
{
emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE,TRUE));
emitcode("pop", "dph");
emitcode("pop", "dpl");
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
}
/* so dptr know contains the address */
size = AOP_SIZE(right);
offset = 0 ;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
char *l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
MOVA(l);
+
+ genSetDPTR(0);
+ _flushLazyDPS();
+
emitcode("movx","@dptr,a");
if (size)
emitcode("inc","dptr");
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
freeAsmop(right,NULL,ic,TRUE);
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
if (AOP_TYPE(result) != AOP_STR) {
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
/* if this is remateriazable */
if (AOP_TYPE(result) == AOP_IMMD) {
emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE,FALSE));
emitcode("mov","dpx,%s",aopGet(AOP(result),2,FALSE,FALSE,TRUE));
emitcode("mov","b,%s",aopGet(AOP(result),3,FALSE,FALSE,TRUE));
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
/* so dptr know contains the address */
freeAsmop(result,NULL,ic,TRUE);
size = AOP_SIZE(right);
offset = 0 ;
+ _startLazyDPSEvaluation();
while (size--) {
char *l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
MOVA(l);
+
+ genSetDPTR(0);
+ _flushLazyDPS();
+
emitcode("lcall","__gptrput");
if (size)
emitcode("inc","dptr");
}
+ _endLazyDPSEvaluation();
}
freeAsmop(right,NULL,ic,TRUE);
{
int size = AOP_SIZE(right);
int offset = 0;
- char *l ;
+ char *l;
+
+#ifdef LAZY_DPS_OPT
+ if (size > 1)
+ {
+ /* This is a net loss for size == 1, but a big gain
+ * otherwise.
+ */
+ D(emitcode(";", "genFarFarAssign (improved)"););
+ aopOp(result,ic,TRUE, TRUE);
+
+ _startLazyDPSEvaluation();
+ while (size--)
+ {
+ aopPut(AOP(result),
+ aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
+ offset);
+ offset++;
+ }
+ _endLazyDPSEvaluation();
+ freeAsmop(result,NULL,ic,FALSE);
+ freeAsmop(right,NULL,ic,FALSE);
+ }
+ else
+#endif
+ {
D(emitcode(";", "genFarFarAssign "););
/* first push the right side on to the stack */
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
MOVA(l);
aopPut(AOP(result),"a",--offset);
}
freeAsmop(result,NULL,ic,FALSE);
- _endAopGetLoop();
-
+ _endLazyDPSEvaluation();
+ }
}
/*-----------------------------------------------------------------*/
offset = 0 ;
if(AOP_TYPE(right) == AOP_LIT)
lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
if((size > 1) &&
(AOP_TYPE(result) != AOP_REG) &&
(AOP_TYPE(right) == AOP_LIT) &&
- !IS_FLOAT(operandType(right)) &&
- (lit < 256L)){
+ !IS_FLOAT(operandType(right))
+#ifndef LAZY_DPS_OPT
+ && (lit < 256L)
+#endif
+ )
+ {
+#ifdef LAZY_DPS_OPT
+ D(emitcode(";", "Kevin's better literal load code"););
+ _startLazyDPSEvaluation();
+ while (size && ((unsigned int)(lit >> (offset*8)) != 0))
+ {
+ aopPut(AOP(result),
+ aopGet(AOP(right),offset,FALSE,FALSE,TRUE),
+ offset);
+ offset++;
+ size--;
+ }
+ /* And now fill the rest with zeros. */
+ if (size)
+ {
+ emitcode("clr","a");
+ }
+ while (size--)
+ {
+ aopPut(AOP(result), "a", offset++);
+ }
+ _endLazyDPSEvaluation();
+#else
emitcode("clr","a");
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--)
{
if((unsigned int)((lit >> (size*8)) & 0x0FFL)== 0)
aopGet(AOP(right),size,FALSE,FALSE,FALSE),
size);
}
- _endAopGetLoop();
- } else {
- _startAopGetLoop();
+ _endLazyDPSEvaluation();
+#endif
+ }
+ else
+ {
+ _startLazyDPSEvaluation();
while (size--)
{
aopPut(AOP(result),
offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
}
release:
/* if they in different places then copy */
size = AOP_SIZE(result);
offset = 0 ;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
aopPut(AOP(result),
aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
goto release;
}
/* the first two bytes are known */
size = GPTRSIZE - 1;
offset = 0 ;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
aopPut(AOP(result),
aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
/* the last byte depending on type */
switch (p_type) {
/* just copy the pointers */
size = AOP_SIZE(result);
offset = 0 ;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
aopPut(AOP(result),
aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
goto release ;
}
/* we move to result for the size of source */
size = AOP_SIZE(right);
offset = 0 ;
- _startAopGetLoop();
+ _startLazyDPSEvaluation();
while (size--) {
aopPut(AOP(result),
aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
offset);
offset++;
}
- _endAopGetLoop();
+ _endLazyDPSEvaluation();
/* now depending on the sign of the source && destination */
size = AOP_SIZE(result) - AOP_SIZE(right);
/* if unsigned or not an integral type */
- if (SPEC_USIGN(rtype) || !IS_SPEC(rtype)) {
+ /* also, if the source is a bit, we don't need to sign extend, because
+ * it can't possibly have set the sign bit.
+ */
+ if (SPEC_USIGN(rtype) || !IS_SPEC(rtype) || AOP_TYPE(right) == AOP_CRY)
+ {
while (size--)
+ {
aopPut(AOP(result),zero,offset++);
- } else {
+ }
+ }
+ else
+ {
/* we need to extend the sign :{ */
char *l = aopGet(AOP(right),AOP_SIZE(right) - 1,
FALSE,FALSE,TRUE);
}
/*-----------------------------------------------------------------*/
-/* gen390Code - generate code for 8051 based controllers */
+/* gen390Code - generate code for Dallas 390 based controllers */
/*-----------------------------------------------------------------*/
void gen390Code (iCode *lic)
{
lineHead = lineCurr = NULL;
+#if 0
+ //REMOVE ME!!!
/* print the allocation information */
if (allocInfo)
printAllocInfo( currFunc, codeOutFile);
+#endif
/* if debug information required */
-/* if (options.debug && currFunc) { */
- if (currFunc) {
+ if (options.debug && currFunc) {
+ //jwk if (currFunc) {
cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
_G.debugLine = 1;
if (IS_STATIC(currFunc->etype))
projects / fw / sdcc / blobdiff