Slightly better genCmp(signed) 20597 159 195B
Better reg packing, first peephole 20038 163 1873
With assign packing 19281 165 1849
+ 5/3/00 17741 185 17B6
Michael Hope <michaelh@earthling.net> 2000
Based on the mcs51 generator - Sandeep Dutta . sandeep.dutta@usa.net (1998)
stuff. This is what it is all about CODE GENERATION for a specific MCU.
Some of the routines may be reusable, will have to see */
+
static char *zero = "#0x00";
static char *one = "#0x01";
static char *spname ;
set *sendSet = NULL;
const char *_shortJP = "jp";
-enum {
+typedef enum {
PAIR_INVALID,
PAIR_BC,
PAIR_DE,
PAIR_HL,
+ PAIR_IY,
+ PAIR_IX,
NUM_PAIRS
-};
+} PAIR_ID;
static struct {
const char *name;
{ "??", "?", "?" },
{ "bc", "c", "b" },
{ "de", "e", "d" },
- { "hl", "l", "h" }
+ { "hl", "l", "h" },
+ { "iy", "iy.l?", "iy.h?" },
+ { "ix", "ix.l?", "ix.h?" }
};
#define RESULTONSTACK(x) \
unsigned char SRMask[] = {0xFF, 0x7F, 0x3F, 0x1F, 0x0F,
0x07, 0x03, 0x01, 0x00};
-static int _lastStack = 0;
-static int _pushed = 0;
-static int _spoffset;
-static int _lastHLOff = 0;
-static asmop *_lastHL;
-
#define LSB 0
#define MSB16 1
#define MSB24 2
#define MSB32 3
/* Stack frame:
-
IX+4 param0 LH
IX+2 ret LH
IX+0 ix LH
static struct {
struct {
+ AOP_TYPE last_type;
const char *lit;
int offset;
- } HL;
+ } pairs[NUM_PAIRS];
+ struct {
+ int last;
+ int pushed;
+ int offset;
+ } stack;
+ int frameId;
} _G;
static char *aopGet(asmop *aop, int offset, bool bit16);
break;
}
}
- assert(0);
+ wassert(0);
return NULL;
}
-static int getPairId(asmop *aop)
+static PAIR_ID getPairId(asmop *aop)
{
if (aop->size == 2) {
if (aop->type == AOP_REG) {
return (getPairId(aop) != PAIR_INVALID);
}
+bool isPtrPair(asmop *aop)
+{
+ PAIR_ID pairId = getPairId(aop);
+ switch (pairId) {
+ case PAIR_HL:
+ case PAIR_IY:
+ case PAIR_IX:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
/** Push a register pair onto the stack */
void genPairPush(asmop *aop)
{
if (sym->onStack || sym->iaccess) {
sym->aop = aop = newAsmop(AOP_STK);
aop->size = getSize(sym->type);
- _lastHL = NULL;
aop->aopu.aop_stk = sym->stack;
return aop;
}
/* in which case DPTR gets the address */
if (IS_GB) {
sym->aop = aop = newAsmop(AOP_HL);
- _lastHL = NULL;
}
else {
sym->aop = aop = newAsmop(AOP_IY);
- emitcode ("ld","iy,#%s ; a", sym->rname);
}
aop->size = getSize(sym->type);
aop->aopu.aop_dir = sym->rname;
aop->freed = 1;
- switch (aop->type) {
- case AOP_STK :
- break;
- }
-
dealloc:
/* all other cases just dealloc */
if (op ) {
bool isLitWord(asmop *aop)
{
- if (aop->size != 2)
- return FALSE;
+ /* if (aop->size != 2)
+ return FALSE;*/
switch (aop->type) {
case AOP_IMMD:
case AOP_LIT:
char *s = buffer ;
char *rs;
- if (aop->size != 2)
+#if 0
+ if (aop->size != 2 && aop->type != AOP_HL)
return NULL;
- assert(offset == 0);
+#endif
+ wassert(offset == 0);
/* depending on type */
switch (aop->type) {
+ case AOP_HL:
+ case AOP_IY:
case AOP_IMMD:
sprintf (s,"%s%s",with_hash ? "#" : "", aop->aopu.aop_immd);
ALLOC_ATOMIC(rs,strlen(s)+1);
strcpy(rs,s);
return rs;
-
case AOP_LIT: {
value * val = aop->aopu.aop_lit;
/* if it is a float then it gets tricky */
ALLOC_ATOMIC(rs,strlen(buffer)+1);
return strcpy (rs,buffer);
}
- assert(0);
+ wassert(0);
return NULL;
}
+ default:
+ return NULL;
}
- return NULL;
}
char *aopGetWord(asmop *aop, int offset)
static void adjustPair(const char *pair, int *pold, int new)
{
- assert(pair);
+ wassert(pair);
while (*pold < new) {
emitcode("inc", "%s", pair);
}
}
-static void spillHL(void)
+static void spillPair(PAIR_ID pairId)
+{
+ _G.pairs[pairId].last_type = AOP_INVALID;
+ _G.pairs[pairId].lit = NULL;
+}
+
+static void spillCached(void)
{
- _G.HL.lit = NULL;
+ spillPair(PAIR_HL);
+ spillPair(PAIR_IY);
}
static bool requiresHL(asmop *aop)
}
}
-static void fetchHL(asmop *aop)
-{
- spillHL();
- if (IS_GB && requiresHL(aop)) {
- aopGet(aop, 0, FALSE);
- emitcode("ld", "a,(hl+)");
- emitcode("ld", "h,(hl)");
- emitcode("ld", "l,a");
- }
- else {
- emitcode("ld", "l,%s", aopGet(aop, 0, FALSE));
- emitcode("ld", "h,%s", aopGet(aop, 1, FALSE));
- }
-}
-
-static void fetchLitPair(int pairId, asmop *left, int offset)
+static void fetchLitPair(PAIR_ID pairId, asmop *left, int offset)
{
const char *l;
const char *pair = _pairs[pairId].name;
l = aopGetLitWordLong(left, 0, FALSE);
- assert(l && pair);
+ wassert(l && pair);
if (isPtr(pair)) {
- if (_G.HL.lit && !strcmp(_G.HL.lit, l) && abs(_G.HL.offset - offset) < 3) {
- adjustPair(pair, &_G.HL.offset, offset);
- }
- else {
- _G.HL.lit = _strdup(l);
- _G.HL.offset = offset;
- emitcode("ld", "%s,#%s + %d", pair, l, offset);
+ if (pairId == PAIR_HL || pairId == PAIR_IY) {
+ if (_G.pairs[pairId].lit && !strcmp(_G.pairs[pairId].lit, l)) {
+ if (pairId == PAIR_HL && abs(_G.pairs[pairId].offset - offset) < 3) {
+ adjustPair(pair, &_G.pairs[pairId].offset, offset);
+ return;
+ }
+ if (pairId == PAIR_IY && abs(offset)<127) {
+ return;
+ }
+ }
}
+ _G.pairs[pairId].last_type = left->type;
+ _G.pairs[pairId].lit = _strdup(l);
+ _G.pairs[pairId].offset = offset;
}
- else {
- /* Both a lit on the right and a true symbol on the left */
+ /* Both a lit on the right and a true symbol on the left */
+ if (offset)
emitcode("ld", "%s,#%s + %d", pair, l, offset);
- }
+ else
+ emitcode("ld", "%s,#%s", pair, l);
}
-static void setupHL(asmop *aop, int offset)
+static void fetchPair(PAIR_ID pairId, asmop *aop)
{
- spillHL();
- if (_lastHL != aop) {
- switch (aop->type) {
- case AOP_HL:
- emitcode("", ";1");
- fetchLitPair(PAIR_HL, aop, offset);
- break;
- case AOP_STK:
- /* In some cases we can still inc or dec hl */
- emitcode("lda", "hl,%d+%d+%d(sp)", aop->aopu.aop_stk+offset, _pushed, _spoffset);
- break;
- default:
- assert(0);
+ /* if this is remateriazable */
+ if (isLitWord(aop)) {
+ fetchLitPair(pairId, aop, 0);
+ }
+ else { /* we need to get it byte by byte */
+ if (pairId == PAIR_HL && IS_GB && requiresHL(aop)) {
+ aopGet(aop, 0, FALSE);
+ emitcode("ld", "a,(hl+)");
+ emitcode("ld", "h,(hl)");
+ emitcode("ld", "l,a");
+ }
+ else {
+ emitcode("ld", "%s,%s", _pairs[pairId].l, aopGet(aop, 0, FALSE));
+ emitcode("ld", "%s,%s", _pairs[pairId].h, aopGet(aop, 1, FALSE));
}
- _lastHL = aop;
- _lastHLOff = offset;
+ /* PENDING: check? */
+ if (pairId == PAIR_HL)
+ spillPair(PAIR_HL);
}
- else {
- while (offset < _lastHLOff) {
- emitcode("dec", "hl");
- _lastHLOff--;
+}
+
+static void fetchHL(asmop *aop)
+{
+ fetchPair(PAIR_HL, aop);
+}
+
+static void setupPair(PAIR_ID pairId, asmop *aop, int offset)
+{
+ assert(pairId == PAIR_HL || pairId == PAIR_IY);
+
+ switch (aop->type) {
+ case AOP_IY:
+ case AOP_HL:
+ fetchLitPair(pairId, aop, offset);
+ _G.pairs[pairId].offset = offset;
+ break;
+ case AOP_STK: {
+ /* Doesnt include _G.stack.pushed */
+ int abso = aop->aopu.aop_stk + offset + _G.stack.offset;
+ assert(pairId == PAIR_HL);
+ /* In some cases we can still inc or dec hl */
+ if (_G.pairs[pairId].last_type == AOP_STK && abs(_G.pairs[pairId].offset - abso) < 3) {
+ adjustPair(_pairs[pairId].name, &_G.pairs[pairId].offset, abso);
}
- while (offset > _lastHLOff) {
- emitcode("inc", "hl");
- _lastHLOff++;
+ else {
+ emitcode("lda", "hl,%d+%d+%d(sp)", aop->aopu.aop_stk+offset, _G.stack.pushed, _G.stack.offset);
}
+ _G.pairs[pairId].offset = abso;
+ break;
}
+ default:
+ wassert(0);
+ }
+ _G.pairs[pairId].last_type = aop->type;
+}
+
+static void emitLabel(int key)
+{
+ emitcode("", LABEL_STR ":", key);
+ spillCached();
}
/*-----------------------------------------------------------------*/
sprintf (s,"#%s ; 5",aop->aopu.aop_immd);
else
if (offset) {
- assert(offset == 1);
+ wassert(offset == 1);
sprintf(s,"#>%s",
aop->aopu.aop_immd);
}
return rs;
case AOP_DIR:
- assert(IS_GB);
+ wassert(IS_GB);
emitcode("ld", "a,(%s+%d) ; x", aop->aopu.aop_dir, offset);
sprintf(s, "a");
ALLOC_ATOMIC(rs,strlen(s)+1);
return aop->aopu.aop_reg[offset]->name;
case AOP_HL:
- assert(IS_GB);
+ wassert(IS_GB);
emitcode("", ";3");
- setupHL(aop, offset);
+ setupPair(PAIR_HL, aop, offset);
sprintf(s, "(hl)");
return _strdup("(hl)");
case AOP_IY:
+ wassert(IS_Z80);
+ setupPair(PAIR_IY, aop, offset);
sprintf(s,"%d(iy)", offset);
ALLOC_ATOMIC(rs,strlen(s)+1);
strcpy(rs,s);
case AOP_STK:
if (IS_GB) {
- setupHL(aop, offset);
+ setupPair(PAIR_HL, aop, offset);
sprintf(s, "(hl)");
}
else {
- sprintf(s,"%d(ix) ; %u", aop->aopu.aop_stk+offset, offset);
+ sprintf(s,"%d(ix)", aop->aopu.aop_stk+offset);
}
ALLOC_ATOMIC(rs,strlen(s)+1);
strcpy(rs,s);
return rs;
case AOP_CRY:
- assert(0);
+ wassert(0);
case AOP_ACC:
if (!offset) {
case AOP_STR:
aop->coff = offset;
return aop->aopu.aop_str[offset];
+ default:
+ break;
}
-
- fprintf(stderr, "Type %u\n", aop->type);
-
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "aopget got unsupported aop->type");
+ wassertl(0, "aopget got unsupported aop->type");
exit(0);
}
switch (aop->type) {
case AOP_DIR:
/* Direct. Hmmm. */
- assert(IS_GB);
+ wassert(IS_GB);
emitcode("ld", "a,%s", s);
emitcode("ld", "(%s+%d),a", aop->aopu.aop_dir, offset);
break;
break;
case AOP_IY:
- assert(!IS_GB);
+ wassert(!IS_GB);
+ setupPair(PAIR_IY, aop, offset);
if (!canAssignToPtr(s)) {
emitcode("ld", "a,%s", s);
emitcode("ld", "%d(iy),a", offset);
break;
case AOP_HL:
- assert(IS_GB);
+ wassert(IS_GB);
if (!strcmp(s, "(hl)")) {
emitcode("ld", "a,(hl)");
s = "a";
}
emitcode("", ";2");
- setupHL(aop, offset);
+ setupPair(PAIR_HL, aop, offset);
emitcode("ld", "(hl),%s", s);
break;
emitcode("ld", "a,(hl)");
s = "a";
}
- setupHL(aop, offset);
+ setupPair(PAIR_HL, aop, offset);
if (!canAssignToPtr(s)) {
emitcode("ld", "a,%s", s);
emitcode("ld", "(hl),a");
emitcode("rla", "");
} else {
/* In bit space but not in C - cant happen */
- assert(0);
+ wassert(0);
}
break;
size = AOP_SIZE(op);
if(size == 3) {
/* pointer */
- assert(0);
+ wassert(0);
}
return size;
}
aopPut(AOP(result),l,offr);
}
else {
- assert(0);
+ wassert(0);
}
}
}
/* if in bit space then a special case */
if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
- assert(0);
+ wassert(0);
}
/* if type float then do float */
if (IS_FLOAT(optype)) {
- assert(0);
+ wassert(0);
}
toBoolean(IC_LEFT(ic));
a special case */
if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
- assert(0);
+ wassert(0);
}
size = AOP_SIZE(IC_RESULT(ic));
case */
if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
- assert(0);
+ wassert(0);
goto release;
}
/* if float then do float stuff */
if (IS_FLOAT(optype)) {
- assert(0);
+ wassert(0);
goto release;
}
int offset = 0;
int size = AOP_SIZE(oper);
- assert(size <= 2);
+ wassert(size <= 2);
while (size--) {
aopPut(AOP(oper),_fReturn[offset],offset);
/* push it on the stack */
if (isPair(AOP(IC_LEFT(ic)))) {
emitcode("push", getPairName(AOP(IC_LEFT(ic))));
- _pushed += 2;
+ _G.stack.pushed += 2;
}
else {
offset = size;
emitcode("ld", "a,%s", l);
emitcode("push", "af");
emitcode("inc", "sp");
- _pushed++;
+ _G.stack.pushed++;
}
}
return ;
size = AOP_SIZE(IC_LEFT(ic));
if (isPair(AOP(IC_LEFT(ic)))) {
- _pushed+=2;
+ _G.stack.pushed+=2;
emitcode("push", "%s", getPairName(AOP(IC_LEFT(ic))));
}
else {
if (size == 2) {
- char *s = aopGetWord(AOP(IC_LEFT(ic)), 0);
- if (s) {
- emitcode("ld", "hl,%s", s);
- emitcode("push", "hl");
- _pushed+=2;
- }
- else {
- /* Optimise here - load into HL then push HL */
- fetchHL(AOP(IC_LEFT(ic)));
- emitcode("push", "hl");
- _pushed += 2;
- }
+ fetchHL(AOP(IC_LEFT(ic)));
+ emitcode("push", "hl ; 2");
+ spillPair(PAIR_HL);
+ _G.stack.pushed += 2;
goto release;
}
offset = size;
emitcode("ld", "a,%s", l);
emitcode("push", "af");
emitcode("inc", "sp");
- _pushed++;
+ _G.stack.pushed++;
}
}
release:
while (size--) {
emitcode("dec", "sp");
emitcode("pop", "hl");
+ spillPair(PAIR_HL);
aopPut(AOP(IC_LEFT(ic)), "l", offset--);
}
}
}
if (ispcall) {
- symbol *rlbl = newiTempLabel(NULL);
-
- emitcode("ld", "hl,#" LABEL_STR, (rlbl->key+100));
- emitcode("push", "hl");
- _pushed += 2;
-
aopOp(IC_LEFT(ic),ic,FALSE);
- fetchHL(AOP(IC_LEFT(ic)));
+
+ if (isLitWord(AOP(IC_LEFT(ic)))) {
+ emitcode("", "; Special case where the pCall is to a constant");
+ emitcode("call", aopGetLitWordLong(AOP(IC_LEFT(ic)), 0, FALSE));
+ }
+ else {
+ symbol *rlbl = newiTempLabel(NULL);
+ spillPair(PAIR_HL);
+ emitcode("ld", "hl,#" LABEL_STR, (rlbl->key+100));
+ emitcode("push", "hl");
+ _G.stack.pushed += 2;
+
+ fetchHL(AOP(IC_LEFT(ic)));
+ emitcode("jp", "(hl)");
+ emitcode("","%05d$:",(rlbl->key+100));
+ _G.stack.pushed -= 2;
+ }
freeAsmop(IC_LEFT(ic),NULL,ic);
-
- emitcode("jp", "(hl)");
- emitcode("","%05d$:",(rlbl->key+100));
- _pushed -= 2;
}
else {
/* make the call */
OP_SYMBOL(IC_LEFT(ic))->name;
emitcode("call", "%s", name);
}
+ spillCached();
/* if we need assign a result value */
if ((IS_ITEMP(IC_RESULT(ic)) &&
/* adjust the stack for parameters if required */
if (IC_LEFT(ic)->parmBytes) {
int i = IC_LEFT(ic)->parmBytes;
- _pushed -= i;
+ _G.stack.pushed -= i;
if (IS_GB) {
emitcode("lda", "sp,%d(sp)", i);
}
else {
+ spillCached();
if (i>6) {
emitcode("ld", "hl,#%d", i);
emitcode("add", "hl,sp");
if (i)
emitcode("inc", "sp");
}
+ spillCached();
}
}
/*-----------------------------------------------------------------*/
static void genFunction (iCode *ic)
{
- symbol *sym;
+ symbol *sym = OP_SYMBOL(IC_LEFT(ic));
link *fetype;
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);
emitcode("", "__%s_start:", sym->rname);
+ emitcode("","%s:",sym->rname);
+
fetype = getSpec(operandType(IC_LEFT(ic)));
/* if critical function then turn interrupts off */
emitcode("add", "ix,sp");
}
- _lastStack = sym->stack;
+ _G.stack.last = sym->stack;
if (sym->stack) {
if (IS_GB) {
emitcode("ld", "sp,hl");
}
}
- _spoffset = sym->stack;
+ _G.stack.offset = sym->stack;
}
/*-----------------------------------------------------------------*/
symbol *sym = OP_SYMBOL(IC_LEFT(ic));
if (IS_ISR(sym->etype)) {
- assert(0);
+ wassert(0);
}
else {
if (SPEC_CRTCL(sym->etype))
emitcode("pop", "de");
}
else {
- if (_spoffset) {
- emitcode("ld", "hl,#%d", _spoffset);
+ if (_G.stack.offset) {
+ emitcode("ld", "hl,#%d", _G.stack.offset);
emitcode("add", "hl,sp");
emitcode("ld", "sp,hl");
}
}
emitcode("pop", "bc");
emitcode("ret", "");
+ emitcode("; Useful for profiling and debugging", "");
+ emitcode(".dw", "%s", sym->rname);
emitcode("", "__%s_end:", sym->rname);
}
- _pushed = 0;
- _spoffset = 0;
+ _G.stack.pushed = 0;
+ _G.stack.offset = 0;
}
/*-----------------------------------------------------------------*/
if (IC_LABEL(ic) == entryLabel)
return ;
- emitcode("", LABEL_STR ":",(IC_LABEL(ic)->key+100));
+ emitLabel(IC_LABEL(ic)->key+100);
}
/*-----------------------------------------------------------------*/
{
unsigned int icount ;
unsigned int size = getDataSize(IC_RESULT(ic));
-
+ PAIR_ID resultId = getPairId(AOP(IC_RESULT(ic)));
+
/* will try to generate an increment */
/* if the right side is not a literal
we cannot */
emitcode("", "; genPlusIncr");
icount = floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
-
/* If result is a pair */
- if (isPair(AOP(IC_RESULT(ic))) && isLitWord(AOP(IC_LEFT(ic)))) {
- fetchLitPair(getPairId(AOP(IC_RESULT(ic))), AOP(IC_LEFT(ic)), icount);
+ if (resultId != PAIR_INVALID) {
+ if (isLitWord(AOP(IC_LEFT(ic)))) {
+ fetchLitPair(getPairId(AOP(IC_RESULT(ic))), AOP(IC_LEFT(ic)), icount);
+ return TRUE;
+ }
+ if (isPair(AOP(IC_LEFT(ic))) && resultId == PAIR_HL && icount > 2) {
+ fetchPair(resultId, AOP(IC_RIGHT(ic)));
+ emitcode("add", "hl,%s", getPairName(AOP(IC_LEFT(ic))));
+ return TRUE;
+ }
+ if (icount > 5)
+ return FALSE;
+ /* Inc a pair */
+ if (!sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
+ if (icount > 2)
+ return FALSE;
+ movLeft2Result(IC_LEFT(ic), 0, IC_RESULT(ic), 0, 0);
+ movLeft2Result(IC_LEFT(ic), 1, IC_RESULT(ic), 1, 0);
+ }
+ while (icount--) {
+ emitcode("inc", "%s", getPairName(AOP(IC_RESULT(ic))));
+ }
return TRUE;
}
/* if the literal value of the right hand side
is greater than 4 then it is not worth it */
if (icount > 4)
- return FALSE ;
+ return FALSE;
- /* Inc a pair */
- if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
- isPair(AOP(IC_RESULT(ic)))) {
- while (icount--) {
- emitcode("inc", "%s", getPairName(AOP(IC_RESULT(ic))));
- }
- return TRUE;
- }
/* if increment 16 bits in register */
if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
(size > 1) &&
emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE));
if(size == 4) {
- assert(0);
+ wassert(0);
}
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
return TRUE;
}
- /* If result is a pair */
- if (isPair(AOP(IC_RESULT(ic)))) {
- movLeft2Result(IC_LEFT(ic), 0, IC_RESULT(ic), 0, 0);
- movLeft2Result(IC_LEFT(ic), 1, IC_RESULT(ic), 1, 0);
- while (icount--)
- emitcode("inc", "%s", getPairName(AOP(IC_RESULT(ic))));
- return TRUE;
- }
-
/* if the sizes are greater than 1 then we cannot */
if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
AOP_SIZE(IC_LEFT(ic)) > 1 )
symbol *tlbl = newiTempLabel(NULL);
/* if the result is a bit */
if (AOP_TYPE(result) == AOP_CRY){
- assert(0);
+ wassert(0);
}
else {
emitcode(_shortJP,"z," LABEL_STR ,tlbl->key+100);
emitcode("ld","a,%s",one);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
outAcc(result);
}
}
if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
/* Cant happen */
- assert(0);
+ wassert(0);
}
/* if left in bit space & right literal */
if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
/* Can happen I guess */
- assert(0);
+ wassert(0);
}
/* if I can do an increment instead
}
}
+ if (isPair(AOP(IC_RIGHT(ic))) && getPairId(AOP(IC_RESULT(ic))) == PAIR_HL) {
+ /* Fetch into HL then do the add */
+ spillPair(PAIR_HL);
+ fetchPair(PAIR_HL, AOP(IC_LEFT(ic)));
+ emitcode("add", "hl,%s", getPairName(AOP(IC_RIGHT(ic))));
+ goto release;
+ }
+
while(size--) {
if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE));
if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
AOP_SIZE(IC_LEFT(ic)) == 3 &&
!sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
- assert(0);
+ wassert(0);
if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
AOP_SIZE(IC_RIGHT(ic)) == 3 &&
!sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
- assert(0);
+ wassert(0);
release:
emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE));
if(size == 4) {
- assert(0);
+ wassert(0);
}
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
return TRUE;
}
#endif
/* if both left & right are in bit space */
if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
- assert(0);
+ wassert(0);
goto release ;
}
if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
AOP_SIZE(IC_LEFT(ic)) == 3 &&
!sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
- assert(0);
+ wassert(0);
release:
freeAsmop(IC_LEFT(ic),NULL,ic);
static void genMult (iCode *ic)
{
/* Shouldn't occur - all done through function calls */
- assert(0);
+ wassert(0);
}
/*-----------------------------------------------------------------*/
static void genDiv (iCode *ic)
{
/* Shouldn't occur - all done through function calls */
- assert(0);
+ wassert(0);
}
/*-----------------------------------------------------------------*/
static void genMod (iCode *ic)
{
/* Shouldn't occur - all done through function calls */
- assert(0);
+ wassert(0);
}
/*-----------------------------------------------------------------*/
if (AOP_TYPE(left) == AOP_CRY &&
AOP_TYPE(right) == AOP_CRY ) {
/* Cant happen on the Z80 */
- assert(0);
+ wassert(0);
} else {
/* subtract right from left if at the
end the carry flag is set then we know that
/* PENDING: ?? */
emitcode("ld","a,%s",one);
emitcode(_shortJP, LABEL_STR ,tlbl->key+100);
- emitcode("", LABEL_STR ":",lbl->key+100);
+ emitLabel(lbl->key+100);
emitcode("xor","a,a");
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
}
/*-----------------------------------------------------------------*/
/* if they are both bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
- assert(0);
+ wassert(0);
} else {
tlbl = newiTempLabel(NULL);
gencjneshort(left, right, tlbl);
if ( IC_TRUE(ifx) ) {
emitcode("jp", LABEL_STR ,IC_TRUE(ifx)->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
} else {
/* PENDING: do this better */
symbol *lbl = newiTempLabel(NULL);
emitcode(_shortJP, LABEL_STR ,lbl->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
emitcode("jp", LABEL_STR ,IC_FALSE(ifx)->key+100);
- emitcode("", LABEL_STR ":",lbl->key+100);
+ emitLabel(lbl->key+100);
}
}
/* mark the icode as generated */
/* if they are both bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
- assert(0);
+ wassert(0);
} else {
gencjne(left,right,newiTempLabel(NULL));
if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
- assert(0);
+ wassert(0);
}
if (ifx) {
genIfxJump(ifx,"a");
/* if both are bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
AOP_TYPE(right) == AOP_CRY ) {
- assert(0);
+ wassert(0);
} else {
tlbl = newiTempLabel(NULL);
toBoolean(left);
emitcode(_shortJP, "z," LABEL_STR ,tlbl->key+100);
toBoolean(right);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
outBitAcc(result);
}
/* if both are bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
AOP_TYPE(right) == AOP_CRY ) {
- assert(0);
+ wassert(0);
} else {
tlbl = newiTempLabel(NULL);
toBoolean(left);
emitcode(_shortJP, "nz," LABEL_STR,tlbl->key+100);
toBoolean(right);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
outBitAcc(result);
}
if(IC_TRUE(ic)){
symbol *nlbl = newiTempLabel(NULL);
emitcode("jp", LABEL_STR, nlbl->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
emitcode("jp",LABEL_STR,IC_TRUE(ic)->key+100);
- emitcode("", LABEL_STR ":",nlbl->key+100);
+ emitLabel(nlbl->key+100);
}
else{
emitcode("jp", LABEL_STR, IC_FALSE(ic)->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
}
ic->generated = 1;
}
size = AOP_SIZE(result);
if (AOP_TYPE(left) == AOP_CRY){
- assert(0);
+ wassert(0);
goto release ;
}
MOVA(aopGet(AOP(left),posbit>>3,FALSE));
// bit = left & 2^n
if(size) {
- assert(0);
+ wassert(0);
emitcode("mov","c,acc.%d",posbit&0x07);
}
// if(left & 2^n)
genIfxJump(ifx, buffer);
}
else {
- assert(0);
+ wassert(0);
}
goto release;
}
symbol *tlbl = newiTempLabel(NULL);
int sizel = AOP_SIZE(left);
if(size) {
- assert(0);
+ wassert(0);
emitcode("setb","c");
}
while(sizel--){
MOVA( aopGet(AOP(left),offset,FALSE));
// byte == 2^n ?
if((posbit = isLiteralBit(bytelit)) != 0) {
- assert(0);
+ wassert(0);
emitcode("jb","acc.%d,%05d$",(posbit-1)&0x07,tlbl->key+100);
}
else{
} else {
if (AOP_TYPE(left) == AOP_ACC) {
- assert(0);
+ wassert(0);
}
else {
MOVA(aopGet(AOP(right),offset,FALSE));
} else {
// left & result in different registers
if(AOP_TYPE(result) == AOP_CRY){
- assert(0);
+ wassert(0);
} else {
for(;(size--);offset++) {
// normal case
size = AOP_SIZE(result);
if (AOP_TYPE(left) == AOP_CRY){
- assert(0);
+ wassert(0);
goto release ;
}
if((AOP_TYPE(right) == AOP_LIT) &&
(AOP_TYPE(result) == AOP_CRY) &&
(AOP_TYPE(left) != AOP_CRY)){
- assert(0);
+ wassert(0);
goto release ;
}
} else {
// left & result in different registers
if(AOP_TYPE(result) == AOP_CRY){
- assert(0);
+ wassert(0);
} else for(;(size--);offset++){
// normal case
// result = left & right
size = AOP_SIZE(result);
if (AOP_TYPE(left) == AOP_CRY){
- assert(0);
+ wassert(0);
goto release ;
}
if((AOP_TYPE(right) == AOP_LIT) &&
(AOP_TYPE(result) == AOP_CRY) &&
(AOP_TYPE(left) != AOP_CRY)){
- assert(0);
+ wassert(0);
goto release ;
}
} else {
// left & result in different registers
if(AOP_TYPE(result) == AOP_CRY){
- assert(0);
+ wassert(0);
} else for(;(size--);offset++){
// normal case
// result = left & right
/*-----------------------------------------------------------------*/
static void genRRC (iCode *ic)
{
- assert(0);
+ wassert(0);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genRLC (iCode *ic)
{
- assert(0);
+ wassert(0);
}
/*-----------------------------------------------------------------*/
{
if(sameRegs(AOP(result), AOP(left)) &&
((offl + MSB16) == offr)){
- assert(0);
+ wassert(0);
} else {
movLeft2Result(left, offl, result, offr, 0);
movLeft2Result(left, offl+1, result, offr+1, 0);
}
if (sign) {
- assert(0);
+ wassert(0);
}
else {
/* if (AOP(result)->type == AOP_REG) {*/
tlbl = newiTempLabel(NULL);
tlbl1 = newiTempLabel(NULL);
emitcode(_shortJP, LABEL_STR ,tlbl1->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
}
emitcode("or", "a,a");
emitcode("rr","%s", l);
}
if (shCount>1) {
- emitcode("", LABEL_STR ":",tlbl1->key+100);
+ emitLabel(tlbl1->key+100);
emitcode("dec", "a");
emitcode(_shortJP,"nz," LABEL_STR ,tlbl->key+100);
}
{
if(sameRegs(AOP(result), AOP(left)) &&
((offl + MSB16) == offr)){
- assert(0);
+ wassert(0);
} else {
/* Copy left into result */
movLeft2Result(left, offl, result, offr, 0);
tlbl = newiTempLabel(NULL);
tlbl1 = newiTempLabel(NULL);
emitcode(_shortJP, LABEL_STR ,tlbl1->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
}
emitcode("or", "a,a");
emitcode("rl","%s", l);
}
if (shCount>1) {
- emitcode("", LABEL_STR ":",tlbl1->key+100);
+ emitLabel(tlbl1->key+100);
emitcode("dec", "a");
emitcode(_shortJP,"nz," LABEL_STR ,tlbl->key+100);
}
{
int size = AOP_SIZE(result);
- assert(size==2);
+ wassert(size==2);
/* if shCount >= 8 */
if (shCount >= 8) {
/* 1 <= shCount <= 7 */
else {
if(size == 1) {
- assert(0);
+ wassert(0);
}
else {
shiftL2Left2Result(left, LSB, result, LSB, shCount);
/* I suppose that the left size >= result size */
if (shCount == 0) {
- assert(0);
+ wassert(0);
}
else if(shCount >= (size * 8))
genlshTwo (result,left,shCount);
break;
case 4:
- assert(0);
+ wassert(0);
break;
default:
- assert(0);
+ wassert(0);
}
}
freeAsmop(left,NULL,ic);
tlbl1 = newiTempLabel(NULL);
emitcode(_shortJP, LABEL_STR ,tlbl1->key+100);
- emitcode("", LABEL_STR ":",tlbl->key+100);
+ emitLabel(tlbl->key+100);
l = aopGet(AOP(result),offset,FALSE);
emitcode("or", "a,a");
while (size--) {
l = aopGet(AOP(result),offset++,FALSE);
emitcode("rl","%s", l);
}
- emitcode("", LABEL_STR ":",tlbl1->key+100);
+ emitLabel(tlbl1->key+100);
emitcode("dec", "a");
emitcode(_shortJP,"nz," LABEL_STR ,tlbl->key+100);
int size = AOP_SIZE(result);
char *l;
- assert(size==1);
- assert(shCount<8);
+ wassert(size==1);
+ wassert(shCount<8);
l = aopGet(AOP(left),0,FALSE);
if (AOP(result)->type == AOP_REG) {
{
MOVA(aopGet(AOP(left),offl,FALSE));
if (sign) {
- assert(0);
+ wassert(0);
}
else {
AccRsh(shCount);
if (shCount >= 8) {
shCount -= 8 ;
if (shCount) {
- assert(0);
+ wassert(0);
shiftR1Left2Result(left, MSB16, result, LSB,
shCount, sign);
}
/* I suppose that the left size >= result size */
if (shCount == 0) {
- assert(0);
+ wassert(0);
}
else if(shCount >= (size * 8))
genrshTwo(result, left, shCount, FALSE);
break;
case 4:
- assert(0);
+ wassert(0);
break;
default:
- assert(0);
+ wassert(0);
}
}
freeAsmop(left,NULL,ic);
return ;
}
else {
- assert(0);
+ wassert(0);
}
}
{
int size, offset ;
link *retype = getSpec(operandType(result));
- const char *ptr = "hl";
+ int pair = PAIR_HL;
if (IS_GB)
- ptr = "de";
+ pair = PAIR_DE;
aopOp(left,ic,FALSE);
aopOp(result,ic,FALSE);
-
- if (isPair(AOP(left)) && (AOP_SIZE(result)==1)) {
+
+ if (isPair(AOP(left)) && AOP_SIZE(result)==1) {
/* Just do it */
- emitcode("ld", "a,(%s)", getPairName(AOP(left)));
- aopPut(AOP(result),"a", 0);
+ if (isPtrPair(AOP(left)))
+ {
+ sprintf(buffer, "(%s)", getPairName(AOP(left)));
+ aopPut(AOP(result), buffer, 0);
+ }
+ else {
+ emitcode("ld", "a,(%s)", getPairName(AOP(left)));
+ aopPut(AOP(result),"a", 0);
+ }
freeAsmop(left,NULL,ic);
goto release;
}
/* For now we always load into IY */
/* if this is remateriazable */
- if (AOP_TYPE(left) == AOP_IMMD)
- emitcode("ld","%s,%s", ptr, aopGet(AOP(left),0,TRUE));
- else { /* we need to get it byte by byte */
- if (IS_GB) {
- emitcode("ld", "e,%s ; 1", aopGet(AOP(left), 0, FALSE));
- emitcode("ld", "d,%s ; 2", aopGet(AOP(left), 1, FALSE));
- }
- else
- fetchHL(AOP(left));
- }
+ fetchPair(pair, AOP(left));
+
/* so iy now contains the address */
freeAsmop(left,NULL,ic);
/* if bit then unpack */
if (IS_BITVAR(retype)) {
- assert(0);
+ wassert(0);
}
else {
size = AOP_SIZE(result);
aopPut(AOP(result),"(hl)",offset++);
}
else {
- emitcode("ld", "a,(%s)", ptr, offset);
+ emitcode("ld", "a,(%s)", _pairs[pair].name, offset);
aopPut(AOP(result),"a",offset++);
}
if (size) {
- emitcode("inc", "%s", ptr);
+ emitcode("inc", "%s", _pairs[pair].name);
}
}
}
return FALSE;
}
-static void fetchPair(int pairId, asmop *aop)
-{
- /* if this is remateriazable */
- if (aop->type == AOP_IMMD) {
- fetchLitPair(pairId, aop, 0);
- }
- else { /* we need to get it byte by byte */
- if (pairId == PAIR_HL) {
- fetchHL(aop);
- }
- else {
- emitcode("ld", "%s,%s", _pairs[pairId].l, 0, TRUE);
- emitcode("ld", "%s,%s", _pairs[pairId].h, 1, TRUE);
- }
- }
-}
-
/*-----------------------------------------------------------------*/
/* genGenPointerSet - stores the value into a pointer location */
/*-----------------------------------------------------------------*/
{
int size, offset ;
link *retype = getSpec(operandType(right));
- int pairId = PAIR_HL;
+ PAIR_ID pairId = PAIR_HL;
aopOp(result,ic,FALSE);
aopOp(right,ic,FALSE);
/* if bit then unpack */
if (IS_BITVAR(retype)) {
- assert(0);
+ wassert(0);
}
else {
size = AOP_SIZE(right);
variable */
if (IS_GB) {
if (sym->onStack) {
- emitcode("lda", "hl,%d+%d+%d(sp)", sym->stack, _pushed, _spoffset);
+ spillCached();
+ emitcode("lda", "hl,%d+%d+%d(sp)", sym->stack, _G.stack.pushed, _G.stack.offset);
emitcode("ld", "d,h");
emitcode("ld", "e,l");
}
aopPut(AOP(IC_RESULT(ic)), "d", 1);
}
else {
+ spillCached();
if (sym->onStack) {
/* if it has an offset then we need to compute it */
- emitcode("push", "de");
- emitcode("push", "ix");
- emitcode("pop", "hl");
- emitcode("ld", "de,#%d", sym->stack);
- emitcode("add", "hl,de");
- emitcode("pop", "de");
+ emitcode("ld", "hl,#%d+%d+%d", sym->stack, _G.stack.pushed, _G.stack.offset);
+ emitcode("add", "hl,sp");
}
else {
emitcode("ld", "hl,#%s", sym->rname);
/* if the result is a bit */
if (AOP_TYPE(result) == AOP_CRY) {
- assert(0);
+ wassert(0);
}
/* general case */
emitcode("ld", "e,%s", l);
emitcode("ld", "d,#0");
jtab = newiTempLabel(NULL);
+ spillCached();
emitcode("ld", "hl,#" LABEL_STR, jtab->key+100);
emitcode("add", "hl,de");
emitcode("add", "hl,de");
if (!IS_GB)
emitcode("pop", "de");
emitcode("jp", "(hl)");
- emitcode("","%05d$:",jtab->key+100);
+ emitLabel(jtab->key+100);
/* now generate the jump labels */
for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
jtab = setNextItem(IC_JTLABELS(ic)))
/* if the result is a bit */
if (AOP_TYPE(result) == AOP_CRY) {
- assert(0);
+ wassert(0);
}
/* if they are the same size : or less */
#if 0
/* if the result is of type pointer */
if (IS_PTR(ctype)) {
- assert(0);
+ wassert(0);
}
#endif
if (isOperandInFarSpace(IC_RESULT(ic)) &&
( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
- assert(0);
+ wassert(0);
} else {
accInUse++;
aopOp(IC_RESULT(ic),ic,FALSE);
case GETHBIT:
emitcode("", "; genHBIT");
- assert(0);
+ wassert(0);
case LEFT_OP:
emitcode("", "; genLeftShift");
projects / fw / sdcc / blobdiff