X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fz80%2Fgen.c;h=4572471a53ccc7a58b21dc5d3de29cf895285652;hb=e812347e2ade88a5922c9cd9eebda93ef9c3fd07;hp=7c15dcaa646585bf0d34ca440730f039d98b0e81;hpb=9527f72e6442a9d8919de3dcf42517ae0e2f80e9;p=fw%2Fsdcc diff --git a/src/z80/gen.c b/src/z80/gen.c index 7c15dcaa..4572471a 100644 --- a/src/z80/gen.c +++ b/src/z80/gen.c @@ -96,7 +96,7 @@ #include "SDCCglue.h" #include "newalloc.h" -/* this is the down and dirty file with all kinds of kludgy & hacky +/* This is the down and dirty file with all kinds of kludgy & hacky 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 */ @@ -108,7 +108,7 @@ PENDING: What if the parameter is a long? Everything is caller saves. i.e. the caller must save any registers that it wants to preserve over the call. - The return value is returned in DEHL. DE is normally used as a + GB: The return value is returned in DEHL. DE is normally used as a working register pair. Caller saves allows it to be used for a return value. va args functions do not use register parameters. All arguments @@ -117,7 +117,9 @@ area. ix-0 is the top most local variable. */ -enum { +enum +{ + /* Set to enable debugging trace statements in the output assembly code. */ DISABLE_DEBUG = 0 }; @@ -133,6 +135,14 @@ static char **_fTmp; extern FILE *codeOutFile; +enum + { + INT8MIN = -128, + INT8MAX = 127 + }; + +/** Enum covering all the possible register pairs. + */ typedef enum { PAIR_INVALID, @@ -156,17 +166,13 @@ static struct { "bc", "c", "b" }, { "de", "e", "d" }, { "hl", "l", "h" }, - { "iy", "iy.l?", "iy.h?" }, - { "ix", "ix.l?", "ix.h?" } + { "iy", "iyl", "iyh" }, + { "ix", "ixl", "ixh" } }; // PENDING #define ACC_NAME _pairs[PAIR_AF].h -#define RESULTONSTACK(x) \ - (IC_RESULT(x) && IC_RESULT(x)->aop && \ - IC_RESULT(x)->aop->type == AOP_STK ) - enum { LSB, @@ -175,8 +181,13 @@ enum MSB32 }; +/** Code generator persistent data. + */ static struct { + /** Used to optimised setting up of a pair by remebering what it + contains and adjusting instead of reloading where possible. + */ struct { AOP_TYPE last_type; @@ -211,8 +222,13 @@ static struct lineNode *head; lineNode *current; int isInline; + allocTrace trace; } lines; + struct + { + allocTrace aops; + } trace; } _G; static const char *aopGet (asmop * aop, int offset, bool bit16); @@ -236,22 +252,22 @@ _getTempPairName(void) return _pairs[_getTempPairId()].name; } -#if 0 -static const char * -_getTempPairPart(int idx) +static PAIR_ID +getFreePairId (iCode *ic) { - wassertl (idx == LSB || idx == MSB16, "Invalid pair offset"); - - if (idx == LSB) + if (!(bitVectBitValue (ic->rMask, B_IDX) || bitVectBitValue(ic->rMask, C_IDX))) + { + return PAIR_BC; + } + else if (IS_Z80 && !(bitVectBitValue (ic->rMask, D_IDX) || bitVectBitValue(ic->rMask, E_IDX))) { - return _pairs[_getTempPairId()].l; + return PAIR_DE; } else { - return _pairs[_getTempPairId()].h; + return PAIR_INVALID; } -} -#endif +} static void _tidyUp (char *buf) @@ -276,6 +292,17 @@ _tidyUp (char *buf) } } +static lineNode * +_newLineNode (char *line) +{ + lineNode *pl; + + pl = traceAlloc(&_G.lines.trace, Safe_alloc ( sizeof (lineNode))); + pl->line = traceAlloc(&_G.lines.trace, Safe_strdup (line)); + + return pl; +} + static void _vemit2 (const char *szFormat, va_list ap) { @@ -285,8 +312,8 @@ _vemit2 (const char *szFormat, va_list ap) _tidyUp (buffer); _G.lines.current = (_G.lines.current ? - connectLine (_G.lines.current, newLineNode (buffer)) : - (_G.lines.head = newLineNode (buffer))); + connectLine (_G.lines.current, _newLineNode (buffer)) : + (_G.lines.head = _newLineNode (buffer))); _G.lines.current->isInline = _G.lines.isInline; } @@ -344,8 +371,8 @@ _emit2 (const char *inst, const char *fmt,...) if (lbp && *lbp) { _G.lines.current = (_G.lines.current ? - connectLine (_G.lines.current, newLineNode (lb)) : - (_G.lines.head = newLineNode (lb))); + connectLine (_G.lines.current, _newLineNode (lb)) : + (_G.lines.head = _newLineNode (lb))); } _G.lines.current->isInline = _G.lines.isInline; va_end (ap); @@ -396,22 +423,18 @@ getPairName (asmop * aop) break; } } - else if (aop->type == AOP_STR) + else if (aop->type == AOP_STR || aop->type == AOP_HLREG) { - switch (*aop->aopu.aop_str[0]) - { - case 'c': - return "bc"; - break; - case 'e': - return "de"; - break; - case 'l': - return "hl"; - break; - } + int i; + for (i = 0; i < NUM_PAIRS; i++) + { + if (strcmp(aop->aopu.aop_str[0], _pairs[i].l) == 0) + { + return _pairs[i].name; + } + } } - wassert (0); + wassertl (0, "Tried to get the pair name of something that isn't a pair"); return NULL; } @@ -435,21 +458,17 @@ getPairId (asmop * aop) return PAIR_HL; } } - if (aop->type == AOP_STR) + else if (aop->type == AOP_STR || aop->type == AOP_HLREG) { - if (!strcmp (aop->aopu.aop_str[0], "c") && !strcmp (aop->aopu.aop_str[1], "b")) - { - return PAIR_BC; - } - if (!strcmp (aop->aopu.aop_str[0], "e") && !strcmp (aop->aopu.aop_str[1], "d")) - { - return PAIR_DE; - } - if (!strcmp (aop->aopu.aop_str[0], "l") && !strcmp (aop->aopu.aop_str[1], "h")) - { - return PAIR_HL; - } - } + int i; + for (i = 0; i < NUM_PAIRS; i++) + { + if (!strcmp (aop->aopu.aop_str[0], _pairs[i].l) && !strcmp (aop->aopu.aop_str[1], _pairs[i].h)) + { + return i; + } + } + } } return PAIR_INVALID; } @@ -475,6 +494,14 @@ isPtrPair (asmop * aop) return FALSE; } } + +static void +spillPair (PAIR_ID pairId) +{ + _G.pairs[pairId].last_type = AOP_INVALID; + _G.pairs[pairId].base = NULL; +} + /** Push a register pair onto the stack */ void genPairPush (asmop * aop) @@ -494,6 +521,7 @@ _pop (PAIR_ID pairId) { emit2 ("pop %s", _pairs[pairId].name); _G.stack.pushed -= 2; + spillPair (pairId); } /*-----------------------------------------------------------------*/ @@ -504,7 +532,7 @@ newAsmop (short type) { asmop *aop; - aop = Safe_calloc (1, sizeof (asmop)); + aop = traceAlloc(&_G.trace.aops, Safe_alloc (sizeof (asmop))); aop->type = type; return aop; } @@ -531,8 +559,21 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool requires_a) /* Assign depending on the storage class */ if (sym->onStack || sym->iaccess) { - emitDebug ("; AOP_STK for %s", sym->rname); - sym->aop = aop = newAsmop (AOP_STK); + /* The pointer that is used depends on how big the offset is. + Normally everything is AOP_STK, but for offsets of < -128 or + > 127 on the Z80 an extended stack pointer is used. + */ + if (IS_Z80 && (options.ommitFramePtr || sym->stack < INT8MIN || sym->stack > (int)(INT8MAX-getSize (sym->type)))) + { + emitDebug ("; AOP_EXSTK for %s", sym->rname); + sym->aop = aop = newAsmop (AOP_EXSTK); + } + else + { + emitDebug ("; AOP_STK for %s", sym->rname); + sym->aop = aop = newAsmop (AOP_STK); + } + aop->size = getSize (sym->type); aop->aopu.aop_stk = sym->stack; return aop; @@ -542,8 +583,7 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool requires_a) if (IS_FUNC (sym->type)) { sym->aop = aop = newAsmop (AOP_IMMD); - aop->aopu.aop_immd = Safe_calloc (1, strlen (sym->rname) + 1); - strcpy (aop->aopu.aop_immd, sym->rname); + aop->aopu.aop_immd = traceAlloc(&_G.trace.aops, Safe_strdup (sym->rname)); aop->size = 2; return aop; } @@ -609,8 +649,7 @@ aopForRemat (symbol * sym) break; } - aop->aopu.aop_immd = Safe_calloc (1, strlen (buffer) + 1); - strcpy (aop->aopu.aop_immd, buffer); + aop->aopu.aop_immd = traceAlloc(&_G.trace.aops, Safe_strdup(buffer)); return aop; } @@ -800,6 +839,16 @@ aopOp (operand * op, iCode * ic, bool result, bool requires_a) return; } + if (sym->ruonly) + { + int i; + aop = op->aop = sym->aop = newAsmop (AOP_STR); + aop->size = getSize (sym->type); + for (i = 0; i < 4; i++) + aop->aopu.aop_str[i] = _fReturn[i]; + return; + } + if (sym->accuse) { if (sym->accuse == ACCUSE_A) @@ -810,32 +859,29 @@ aopOp (operand * op, iCode * ic, bool result, bool requires_a) aop->aopu.aop_str[0] = _pairs[PAIR_AF].h; } - else if (sym->accuse == ACCUSE_HL) + else if (sym->accuse == ACCUSE_SCRATCH) { - wassert (!IS_GB); aop = op->aop = sym->aop = newAsmop (AOP_HLREG); aop->size = getSize (sym->type); wassertl(aop->size <= 2, "Internal error: Caching in HL, but too big to fit in HL"); aop->aopu.aop_str[0] = _pairs[PAIR_HL].l; aop->aopu.aop_str[1] = _pairs[PAIR_HL].h; } + else if (sym->accuse == ACCUSE_IY) + { + aop = op->aop = sym->aop = newAsmop (AOP_HLREG); + aop->size = getSize (sym->type); + wassertl(aop->size <= 2, "Internal error: Caching in IY, but too big to fit in IY"); + aop->aopu.aop_str[0] = _pairs[PAIR_IY].l; + aop->aopu.aop_str[1] = _pairs[PAIR_IY].h; + } else { - wassert (0); + wassertl (0, "Marked as being allocated into A or HL but is actually in neither"); } return; } - if (sym->ruonly) - { - int i; - aop = op->aop = sym->aop = newAsmop (AOP_STR); - aop->size = getSize (sym->type); - for (i = 0; i < 4; i++) - aop->aopu.aop_str[i] = _fReturn[i]; - return; - } - /* else spill location */ sym->aop = op->aop = aop = aopForSym (ic, sym->usl.spillLoc, result, requires_a); @@ -871,6 +917,11 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic) aop->freed = 1; + if (aop->type == AOP_PAIRPTR && IS_Z80 && aop->aopu.aop_pairId == PAIR_DE) + { + _pop (aop->aopu.aop_pairId); + } + dealloc: /* all other cases just dealloc */ if (op) @@ -884,6 +935,7 @@ dealloc: SPIL_LOC (op)->aop = NULL; } } + } bool @@ -905,7 +957,6 @@ char * aopGetLitWordLong (asmop * aop, int offset, bool with_hash) { char *s = buffer; - char *rs; /* depending on type */ switch (aop->type) @@ -926,7 +977,7 @@ aopGetLitWordLong (asmop * aop, int offset, bool with_hash) { tsprintf (s, "%s + %d", aop->aopu.aop_immd, offset); } - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); case AOP_LIT: { @@ -955,19 +1006,31 @@ aopGetLitWordLong (asmop * aop, int offset, bool with_hash) else tsprintf (buffer, "!constword", v); - return gc_strdup(buffer); + return traceAlloc(&_G.trace.aops, Safe_strdup(buffer)); } else { - /* A float */ - Z80_FLOAT f; - convertFloat (&f, floatFromVal (val)); + union { + float f; + unsigned char c[4]; + } + fl; + unsigned int i; + + /* it is type float */ + fl.f = (float) floatFromVal (val); + +#ifdef _BIG_ENDIAN + i = fl.c[3-offset] | (fl.c[3-offset-1]<<8); +#else + i = fl.c[offset] | (fl.c[offset+1]<<8); +#endif if (with_hash) - tsprintf (buffer, "!immedword", f.w[offset / 2]); + tsprintf (buffer, "!immedword", i); else - tsprintf (buffer, "!constword", f.w[offset / 2]); - rs = Safe_calloc (1, strlen (buffer) + 1); - return strcpy (rs, buffer); + tsprintf (buffer, "!constword", i); + + return traceAlloc(&_G.trace.aops, Safe_strdup(buffer)); } } default: @@ -1010,13 +1073,6 @@ adjustPair (const char *pair, int *pold, int new) } } -static void -spillPair (PAIR_ID pairId) -{ - _G.pairs[pairId].last_type = AOP_INVALID; - _G.pairs[pairId].base = NULL; -} - static void spillCached (void) { @@ -1032,6 +1088,8 @@ requiresHL (asmop * aop) case AOP_IY: case AOP_HL: case AOP_STK: + case AOP_EXSTK: + case AOP_HLREG: return TRUE; default: return FALSE; @@ -1060,7 +1118,7 @@ fetchLitPair (PAIR_ID pairId, asmop * left, int offset) adjustPair (pair, &_G.pairs[pairId].offset, offset); return; } - if (pairId == PAIR_IY && abs (offset) < 127) + if (pairId == PAIR_IY && (offset >= INT8MIN && offset <= INT8MAX)) { return; } @@ -1068,7 +1126,7 @@ fetchLitPair (PAIR_ID pairId, asmop * left, int offset) } } _G.pairs[pairId].last_type = left->type; - _G.pairs[pairId].base = gc_strdup (base); + _G.pairs[pairId].base = traceAlloc(&_G.trace.aops, Safe_strdup (base)); _G.pairs[pairId].offset = offset; } /* Both a lit on the right and a true symbol on the left */ @@ -1082,9 +1140,14 @@ fetchPairLong (PAIR_ID pairId, asmop * aop, int offset) if (isLitWord (aop)) { fetchLitPair (pairId, aop, offset); } - else { + else + { + if (getPairId (aop) == pairId) + { + /* Do nothing */ + } /* we need to get it byte by byte */ - if (pairId == PAIR_HL && IS_GB && requiresHL (aop)) { + else if (pairId == PAIR_HL && IS_GB && requiresHL (aop)) { aopGet (aop, offset, FALSE); switch (aop->size - offset) { case 1: @@ -1114,6 +1177,24 @@ fetchPairLong (PAIR_ID pairId, asmop * aop, int offset) emit2("ld %s,!zero", _pairs[pairId].h); } } + else if (pairId == PAIR_IY) + { + if (isPair (aop)) + { + emit2 ("push %s", _pairs[getPairId(aop)].name); + emit2 ("pop iy"); + } + else + { + _push (PAIR_HL); + /* Can't load into parts, so load into HL then exchange. */ + emit2 ("ld %s,%s", _pairs[PAIR_HL].l, aopGet (aop, offset, FALSE)); + emit2 ("ld %s,%s", _pairs[PAIR_HL].h, aopGet (aop, offset + 1, FALSE)); + emit2 ("push hl"); + emit2 ("pop iy"); + _pop (PAIR_HL); + } + } else { emit2 ("ld %s,%s", _pairs[pairId].l, aopGet (aop, offset, FALSE)); emit2 ("ld %s,%s", _pairs[pairId].h, aopGet (aop, offset + 1, FALSE)); @@ -1137,19 +1218,62 @@ fetchHL (asmop * aop) } static void -setupPair (PAIR_ID pairId, asmop * aop, int offset) +setupPairFromSP (PAIR_ID id, int offset) { - assert (pairId == PAIR_HL || pairId == PAIR_IY); + wassertl (id == PAIR_HL, "Setup relative to SP only implemented for HL"); + if (offset < INT8MIN || offset > INT8MAX) + { + emit2 ("ld hl,!immedword", offset); + emit2 ("add hl,sp"); + } + else + { + emit2 ("!ldahlsp", offset); + } +} + +static void +setupPair (PAIR_ID pairId, asmop * aop, int offset) +{ switch (aop->type) { case AOP_IY: + wassertl (pairId == PAIR_IY || pairId == PAIR_HL, "AOP_IY must be in IY or HL"); fetchLitPair (pairId, aop, 0); break; + case AOP_HL: + wassertl (pairId == PAIR_HL, "AOP_HL must be in HL"); + fetchLitPair (pairId, aop, offset); _G.pairs[pairId].offset = offset; break; + + case AOP_EXSTK: + wassertl (IS_Z80, "Only the Z80 has an extended stack"); + wassertl (pairId == PAIR_IY || pairId == PAIR_HL, "The Z80 extended stack must be in IY or HL"); + + { + int offset = aop->aopu.aop_stk + _G.stack.offset; + + if (_G.pairs[pairId].last_type == aop->type && + _G.pairs[pairId].offset == offset) + { + /* Already setup */ + } + else + { + /* PENDING: Do this better. */ + sprintf (buffer, "%d", offset + _G.stack.pushed); + emit2 ("ld %s,!hashedstr", _pairs[pairId].name, buffer); + emit2 ("add %s,sp", _pairs[pairId].name); + _G.pairs[pairId].last_type = aop->type; + _G.pairs[pairId].offset = offset; + } + } + break; + case AOP_STK: { /* Doesnt include _G.stack.pushed */ @@ -1166,11 +1290,16 @@ setupPair (PAIR_ID pairId, asmop * aop, int offset) } else { - emit2 ("!ldahlsp", abso + _G.stack.pushed); + setupPairFromSP (PAIR_HL, abso + _G.stack.pushed); } _G.pairs[pairId].offset = abso; break; } + + case AOP_PAIRPTR: + adjustPair (_pairs[pairId].name, &_G.pairs[pairId].offset, offset); + break; + default: wassert (0); } @@ -1198,7 +1327,7 @@ aopGet (asmop * aop, int offset, bool bit16) aop->type != AOP_LIT) { tsprintf (s, "!zero"); - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); } /* depending on type */ @@ -1221,24 +1350,24 @@ aopGet (asmop * aop, int offset, bool bit16) tsprintf (s, "!lsbimmeds", aop->aopu.aop_immd); break; default: - wassert (0); + wassertl (0, "Fetching from beyond the limits of an immediate value."); } - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); case AOP_DIR: wassert (IS_GB); emit2 ("ld a,(%s+%d)", aop->aopu.aop_dir, offset); sprintf (s, "a"); - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); case AOP_SFR: wassert (IS_GB); emit2 ("ldh a,(%s+%d)", aop->aopu.aop_dir, offset); sprintf (s, "a"); - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); case AOP_REG: return aop->aopu.aop_reg[offset]->name; @@ -1248,14 +1377,21 @@ aopGet (asmop * aop, int offset, bool bit16) setupPair (PAIR_HL, aop, offset); tsprintf (s, "!*hl"); - return gc_strdup (s); + return traceAlloc(&_G.trace.aops, Safe_strdup (s)); case AOP_IY: wassert (IS_Z80); setupPair (PAIR_IY, aop, offset); tsprintf (s, "!*iyx", offset); - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); + + case AOP_EXSTK: + wassert (IS_Z80); + setupPair (PAIR_IY, aop, offset); + tsprintf (s, "!*iyx", offset, offset); + + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); case AOP_STK: if (IS_GB) @@ -1270,10 +1406,10 @@ aopGet (asmop * aop, int offset, bool bit16) tsprintf (s, "!*ixx", aop->aopu.aop_stk + offset); } - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); case AOP_CRY: - wassert (0); + wassertl (0, "Tried to fetch from a bit variable"); case AOP_ACC: if (!offset) @@ -1283,7 +1419,7 @@ aopGet (asmop * aop, int offset, bool bit16) else { tsprintf(s, "!zero"); - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); } case AOP_HLREG: @@ -1300,12 +1436,18 @@ aopGet (asmop * aop, int offset, bool bit16) v >>= (offset * 8); tsprintf (s, "!immedbyte", (unsigned int) v & 0xff); - return gc_strdup(s); + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); } case AOP_STR: aop->coff = offset; return aop->aopu.aop_str[offset]; + case AOP_PAIRPTR: + setupPair (aop->aopu.aop_pairId, aop, offset); + sprintf (s, "(%s)", _pairs[aop->aopu.aop_pairId].name); + + return traceAlloc(&_G.trace.aops, Safe_strdup(s)); + default: break; } @@ -1392,14 +1534,17 @@ aopPut (asmop * aop, const char *s, int offset) case AOP_IY: wassert (!IS_GB); - setupPair (PAIR_IY, aop, offset); if (!canAssignToPtr (s)) { emit2 ("ld a,%s", s); + setupPair (PAIR_IY, aop, offset); emit2 ("ld !*iyx,a", offset); } else - emit2 ("ld !*iyx,%s", offset, s); + { + setupPair (PAIR_IY, aop, offset); + emit2 ("ld !*iyx,%s", offset, s); + } break; case AOP_HL: @@ -1415,6 +1560,21 @@ aopPut (asmop * aop, const char *s, int offset) emit2 ("ld !*hl,%s", s); break; + case AOP_EXSTK: + wassert (!IS_GB); + if (!canAssignToPtr (s)) + { + emit2 ("ld a,%s", s); + setupPair (PAIR_IY, aop, offset); + emit2 ("ld !*iyx,a", offset); + } + else + { + setupPair (PAIR_IY, aop, offset); + emit2 ("ld !*iyx,%s", offset, s); + } + break; + case AOP_STK: if (IS_GB) { @@ -1443,7 +1603,9 @@ aopPut (asmop * aop, const char *s, int offset) emit2 ("ld !*ixx,a", aop->aopu.aop_stk + offset); } else - emit2 ("ld !*ixx,%s", aop->aopu.aop_stk + offset, s); + { + emit2 ("ld !*ixx,%s", aop->aopu.aop_stk + offset, s); + } } break; @@ -1457,7 +1619,7 @@ aopPut (asmop * aop, const char *s, int offset) else { /* In bit space but not in C - cant happen */ - wassert (0); + wassertl (0, "Tried to write into a bit variable"); } break; @@ -1475,8 +1637,7 @@ aopPut (asmop * aop, const char *s, int offset) break; if (offset > 0) { - - emitDebug ("; Error aopPut AOP_ACC"); + wassertl (0, "Tried to access past the end of A"); } else { @@ -1490,6 +1651,11 @@ aopPut (asmop * aop, const char *s, int offset) emit2 ("ld %s,%s", aop->aopu.aop_str[offset], s); break; + case AOP_PAIRPTR: + setupPair (aop->aopu.aop_pairId, aop, offset); + emit2 ("ld (%s),%s", _pairs[aop->aopu.aop_pairId].name, s); + break; + default: werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "aopPut got unsupported aop->type"); @@ -1505,7 +1671,8 @@ aopPut (asmop * aop, const char *s, int offset) static void commitPair (asmop * aop, PAIR_ID id) { - if (id == PAIR_HL && requiresHL (aop)) + /* PENDING: Verify this. */ + if (id == PAIR_HL && requiresHL (aop) && IS_GB) { emit2 ("ld a,l"); emit2 ("ld d,h"); @@ -1514,8 +1681,19 @@ commitPair (asmop * aop, PAIR_ID id) } else { - aopPut (aop, _pairs[id].l, 0); - aopPut (aop, _pairs[id].h, 1); + /* Special cases */ + if (id == PAIR_HL && aop->type == AOP_IY && aop->size == 2) + { + char *l = aopGetLitWordLong (aop, 0, FALSE); + wassert (l); + + emit2 ("ld (%s),%s", l, _pairs[id].name); + } + else + { + aopPut (aop, _pairs[id].l, 0); + aopPut (aop, _pairs[id].h, 1); + } } } @@ -1530,7 +1708,7 @@ getDataSize (operand * op) if (size == 3) { /* pointer */ - wassert (0); + wassertl (0, "Somehow got a three byte data pointer"); } return size; } @@ -1542,7 +1720,8 @@ static void movLeft2Result (operand * left, int offl, operand * result, int offr, int sign) { - const char *l; + const char *l; + if (!sameRegs (AOP (left), AOP (result)) || (offl != offr)) { l = aopGet (AOP (left), offl, FALSE); @@ -1553,11 +1732,56 @@ movLeft2Result (operand * left, int offl, } else { - wassert (0); + if (getDataSize (left) == offl + 1) + { + emit2 ("ld a,%s", l); + aopPut (AOP (result), "a", offr); + } } } } +static void +movLeft2ResultLong (operand * left, int offl, + operand * result, int offr, int sign, + int size) +{ + if (size == 1) + { + movLeft2Result (left, offl, result, offr, sign); + } + else + { + wassertl (offl == 0 && offr == 0, "Only implemented for zero offset"); + wassertl (size == 2, "Only implemented for two bytes or one"); + + if ( IS_GB && requiresHL ( AOP (left)) && getPairId ( AOP (result)) == PAIR_HL) + { + emit2 ("ld a,%s", aopGet (AOP (left), LSB, FALSE)); + emit2 ("ld h,%s", aopGet (AOP (left), MSB16, FALSE)); + emit2 ("ld l,a"); + } + else if ( getPairId ( AOP (result)) == PAIR_IY) + { + PAIR_ID id = getPairId (AOP (left)); + if (id != PAIR_INVALID) + { + emit2("push %s", _pairs[id].name); + emit2("pop iy"); + } + else + { + /* PENDING */ + emitDebug("Error"); + } + } + else + { + movLeft2Result (left, offl, result, offr, sign); + movLeft2Result (left, offl+1, result, offr+1, sign); + } + } +} /** Put Acc into a register set */ @@ -1587,8 +1811,7 @@ outBitCLong (operand * result, bool swap_sense) /* if the result is bit */ if (AOP_TYPE (result) == AOP_CRY) { - emitDebug ("; Note: outBitC form 1"); - aopPut (AOP (result), "blah", 0); + wassertl (0, "Tried to write carry to a bit"); } else { @@ -1631,6 +1854,44 @@ _toBoolean (operand * oper) } } +/*-----------------------------------------------------------------*/ +/* genNotFloat - generates not for float operations */ +/*-----------------------------------------------------------------*/ +static void +genNotFloat (operand * op, operand * res) +{ + int size, offset; + symbol *tlbl; + + emitDebug ("; genNotFloat"); + + /* we will put 127 in the first byte of + the result */ + aopPut (AOP (res), "!immedbyte", 0x7F); + size = AOP_SIZE (op) - 1; + offset = 1; + + _moveA (aopGet (op->aop, offset++, FALSE)); + + while (size--) + { + emit2 ("or a,%s", aopGet (op->aop, offset++, FALSE)); + } + + tlbl = newiTempLabel (NULL); + aopPut (res->aop, "!one", 1); + emit2 ("!shortjp z !tlabel", tlbl->key + 100); + aopPut (res->aop, "!zero", 1); + + emitLabel(tlbl->key + 100); + + size = res->aop->size - 2; + offset = 2; + /* put zeros in the rest */ + while (size--) + aopPut (res->aop, "!zero", offset++); +} + /*-----------------------------------------------------------------*/ /* genNot - generate code for ! operation */ /*-----------------------------------------------------------------*/ @@ -1646,13 +1907,14 @@ genNot (iCode * ic) /* if in bit space then a special case */ if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to negate a bit"); } /* if type float then do float */ if (IS_FLOAT (optype)) { - wassert (0); + genNotFloat (IC_LEFT (ic), IC_RESULT (ic)); + goto release; } _toBoolean (IC_LEFT (ic)); @@ -1664,6 +1926,7 @@ genNot (iCode * ic) emit2 ("sub a,!one"); outBitC (IC_RESULT (ic)); + release: /* release the aops */ freeAsmop (IC_LEFT (ic), NULL, ic); freeAsmop (IC_RESULT (ic), NULL, ic); @@ -1688,7 +1951,7 @@ genCpl (iCode * ic) if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY && AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) { - wassert (0); + wassertl (0, "Left and the result are in bit space"); } size = AOP_SIZE (IC_RESULT (ic)); @@ -1758,6 +2021,32 @@ _gbz80_emitAddSubLong (iCode *ic, bool isAdd) _gbz80_emitAddSubLongLong (ic, AOP (IC_LEFT (ic)), AOP (IC_RIGHT (ic)), isAdd); } +/*-----------------------------------------------------------------*/ +/* genUminusFloat - unary minus for floating points */ +/*-----------------------------------------------------------------*/ +static void +genUminusFloat (operand * op, operand * result) +{ + int size, offset = 0; + + emitDebug("; genUminusFloat"); + + /* for this we just need to flip the + first it then copy the rest in place */ + size = AOP_SIZE (op) - 1; + + _moveA(aopGet (AOP (op), MSB32, FALSE)); + + emit2("xor a,!immedbyte", 0x80); + aopPut (AOP (result), "a", MSB32); + + while (size--) + { + aopPut (AOP (result), aopGet (AOP (op), offset, FALSE), offset); + offset++; + } +} + /*-----------------------------------------------------------------*/ /* genUminus - unary minus code generation */ /*-----------------------------------------------------------------*/ @@ -1776,7 +2065,7 @@ genUminus (iCode * ic) if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY && AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) { - wassert (0); + wassertl (0, "Left and right are in bit space"); goto release; } @@ -1786,10 +2075,13 @@ genUminus (iCode * ic) /* if float then do float stuff */ if (IS_FLOAT (optype)) { - wassert (0); + genUminusFloat (IC_LEFT (ic), IC_RESULT (ic)); goto release; } + /* otherwise subtract from zero */ + size = AOP_SIZE (IC_LEFT (ic)); + if (AOP_SIZE (IC_RESULT (ic)) == 4 && IS_GB) { /* Create a new asmop with value zero */ @@ -1800,8 +2092,6 @@ genUminus (iCode * ic) goto release; } - /* otherwise subtract from zero */ - size = AOP_SIZE (IC_LEFT (ic)); offset = 0; _clearCarry(); while (size--) @@ -1837,13 +2127,9 @@ assignResultValue (operand * oper) int size = AOP_SIZE (oper); bool topInA = 0; - wassert (size <= 4); + wassertl (size <= 4, "Got a result that is bigger than four bytes"); topInA = requiresHL (AOP (oper)); -#if 0 - if (!IS_GB) - wassert (size <= 2); -#endif if (IS_GB && size == 4 && requiresHL (AOP (oper))) { /* We do it the hard way here. */ @@ -1863,6 +2149,25 @@ assignResultValue (operand * oper) } } +/** Simple restore that doesn't take into account what is used in the + return. +*/ +static void +_restoreRegsAfterCall(void) +{ + if (_G.stack.pushedDE) + { + _pop ( PAIR_DE); + _G.stack.pushedDE = FALSE; + } + if (_G.stack.pushedBC) + { + _pop ( PAIR_BC); + _G.stack.pushedBC = FALSE; + } + _G.saves.saved = FALSE; +} + static void _saveRegsForCall(iCode *ic, int sendSetSize) { @@ -1893,19 +2198,7 @@ _saveRegsForCall(iCode *ic, int sendSetSize) bool bcInRet = FALSE, deInRet = FALSE; bitVect *rInUse; -#if 1 rInUse = bitVectCplAnd (bitVectCopy (ic->rMask), ic->rUsed); -#else - if (IC_RESULT(ic)) - { - rInUse = bitVectCplAnd (bitVectCopy (ic->rMask), z80_rUmaskForOp (IC_RESULT(ic))); - } - else - { - /* Has no result, so in use is all of in use */ - rInUse = ic->rMask; - } -#endif deInUse = bitVectBitValue (rInUse, D_IDX) || bitVectBitValue(rInUse, E_IDX); bcInUse = bitVectBitValue (rInUse, B_IDX) || bitVectBitValue(rInUse, C_IDX); @@ -1980,7 +2273,7 @@ genIpush (iCode * ic) size = AOP_SIZE (IC_LEFT (ic)); - if (isPair (AOP (IC_LEFT (ic)))) + if (isPair (AOP (IC_LEFT (ic))) && size == 2) { _G.stack.pushed += 2; emit2 ("push %s", getPairName (AOP (IC_LEFT (ic)))); @@ -2140,7 +2433,7 @@ _opUsesPair (operand * op, iCode * ic, PAIR_ID pairId) static void emitCall (iCode * ic, bool ispcall) { - sym_link *detype = getSpec (operandType (IC_LEFT (ic))); + sym_link *dtype = operandType (IC_LEFT (ic)); bitVect *rInUse = bitVectCplAnd (bitVectCopy (ic->rMask), ic->rUsed); @@ -2214,7 +2507,7 @@ emitCall (iCode * ic, bool ispcall) if (ispcall) { - if (IS_BANKEDCALL (detype)) + if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype))) { werror (W_INDIR_BANKED); } @@ -2222,7 +2515,6 @@ emitCall (iCode * ic, bool ispcall) if (isLitWord (AOP (IC_LEFT (ic)))) { - emitDebug ("; Special case where the pCall is to a constant"); emit2 ("call %s", aopGetLitWordLong (AOP (IC_LEFT (ic)), 0, FALSE)); } else @@ -2245,7 +2537,7 @@ emitCall (iCode * ic, bool ispcall) char *name = OP_SYMBOL (IC_LEFT (ic))->rname[0] ? OP_SYMBOL (IC_LEFT (ic))->rname : OP_SYMBOL (IC_LEFT (ic))->name; - if (IS_BANKEDCALL (detype)) + if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype))) { emit2 ("call banked_call"); emit2 ("!dws", name); @@ -2305,10 +2597,11 @@ emitCall (iCode * ic, bool ispcall) if (i) emit2 ("inc sp"); } - spillCached (); } } + spillCached (); + if (_G.stack.pushedDE) { bool dInUse = bitVectBitValue(rInUse, D_IDX); @@ -2410,28 +2703,20 @@ static void genFunction (iCode * ic) { symbol *sym = OP_SYMBOL (IC_LEFT (ic)); - sym_link *fetype; + sym_link *ftype; #if CALLEE_SAVES bool bcInUse = FALSE; bool deInUse = FALSE; #endif - setArea (IS_NONBANKED (sym->etype)); + setArea (IFFUNC_NONBANKED (sym->type)); /* PENDING: Reset the receive offset as it doesn't seem to get reset anywhere else. */ _G.receiveOffset = 0; -#if 0 - /* PENDING: hack */ - if (!IS_STATIC (sym->etype)) - { - addSetIfnotP (&publics, sym); - } -#endif - /* Record the last function name for debugging. */ _G.lastFunctionName = sym->rname; @@ -2446,14 +2731,14 @@ genFunction (iCode * ic) emit2 ("!profileenter"); } - fetype = getSpec (operandType (IC_LEFT (ic))); + ftype = operandType (IC_LEFT (ic)); /* if critical function then turn interrupts off */ - if (SPEC_CRTCL (fetype)) + if (IFFUNC_ISCRITICAL (ftype)) emit2 ("!di"); /* if this is an interrupt service routine then save all potentially used registers. */ - if (IS_ISR (sym->etype)) + if (IFFUNC_ISISR (sym->type)) { emit2 ("!pusha"); } @@ -2511,7 +2796,9 @@ genFunction (iCode * ic) /* adjust the stack for the function */ _G.stack.last = sym->stack; - if (sym->stack) + if (sym->stack && IS_GB && sym->stack > -INT8MIN) + emit2 ("!enterxl", sym->stack); + else if (sym->stack) emit2 ("!enterx", sym->stack); else emit2 ("!enter"); @@ -2526,18 +2813,22 @@ genEndFunction (iCode * ic) { symbol *sym = OP_SYMBOL (IC_LEFT (ic)); - if (IS_ISR (sym->etype)) + if (IFFUNC_ISISR (sym->type)) { - wassert (0); + wassertl (0, "Tried to close an interrupt support function"); } else { - if (SPEC_CRTCL (sym->etype)) + if (IFFUNC_ISCRITICAL (sym->type)) emit2 ("!ei"); /* PENDING: calleeSave */ - if (_G.stack.offset) + if (_G.stack.offset && IS_GB && _G.stack.offset > INT8MAX) + { + emit2 ("!leavexl", _G.stack.offset); + } + else if (_G.stack.offset) { emit2 ("!leavex", _G.stack.offset); } @@ -2685,14 +2976,27 @@ genPlusIncr (iCode * ic) { if (isLitWord (AOP (IC_LEFT (ic)))) { - fetchLitPair (getPairId (AOP (IC_RESULT (ic))), AOP (IC_LEFT (ic)), icount); + 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))); - emit2 ("add hl,%s", getPairName (AOP (IC_LEFT (ic)))); - return TRUE; + if (getPairId (AOP (IC_LEFT (ic))) == PAIR_HL) + { + PAIR_ID freep = getFreePairId (ic); + if (freep != PAIR_INVALID) + { + fetchPair (freep, AOP (IC_RIGHT (ic))); + emit2 ("add hl,%s", _pairs[freep].name); + return TRUE; + } + } + else + { + fetchPair (resultId, AOP (IC_RIGHT (ic))); + emit2 ("add hl,%s", getPairName (AOP (IC_LEFT (ic)))); + return TRUE; + } } if (icount > 5) return FALSE; @@ -2701,8 +3005,7 @@ genPlusIncr (iCode * 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); + movLeft2ResultLong (IC_LEFT (ic), 0, IC_RESULT (ic), 0, 0, 2); } while (icount--) { @@ -2711,6 +3014,13 @@ genPlusIncr (iCode * ic) return TRUE; } + if (IS_Z80 && isLitWord (AOP (IC_LEFT (ic))) && size == 2) + { + fetchLitPair (PAIR_HL, AOP (IC_LEFT (ic)), icount); + commitPair (AOP (IC_RESULT (ic)), PAIR_HL); + return TRUE; + } + /* if the literal value of the right hand side is greater than 4 then it is not worth it */ if (icount > 4) @@ -2742,6 +3052,18 @@ genPlusIncr (iCode * ic) AOP_SIZE (IC_LEFT (ic)) > 1) return FALSE; + /* If the result is in a register then we can load then increment. + */ + if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG) + { + aopPut (AOP (IC_RESULT (ic)), aopGet (AOP (IC_LEFT (ic)), LSB, FALSE), LSB); + while (icount--) + { + emit2 ("inc %s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE)); + } + return TRUE; + } + /* we can if the aops of the left & result match or if they are in registers and the registers are the same */ @@ -2767,7 +3089,7 @@ outBitAcc (operand * result) /* if the result is a bit */ if (AOP_TYPE (result) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to write A into a bit"); } else { @@ -2778,6 +3100,86 @@ outBitAcc (operand * result) } } +bool +couldDestroyCarry (asmop *aop) +{ + if (aop) + { + if (aop->type == AOP_EXSTK || aop->type == AOP_IY) + { + return TRUE; + } + } + return FALSE; +} + +static void +shiftIntoPair (int idx, asmop *aop) +{ + PAIR_ID id = PAIR_INVALID; + + wassertl (IS_Z80, "Only implemented for the Z80"); + // wassertl (aop->type == AOP_EXSTK, "Only implemented for EXSTK"); + + switch (idx) + { + case 0: + id = PAIR_HL; + break; + case 1: + id = PAIR_DE; + _push (PAIR_DE); + break; + default: + wassertl (0, "Internal error - hit default case"); + } + + emitDebug ("; Shift into pair idx %u", idx); + + if (id == PAIR_HL) + { + setupPair (PAIR_HL, aop, 0); + } + else + { + setupPair (PAIR_IY, aop, 0); + emit2 ("push iy"); + emit2 ("pop %s", _pairs[id].name); + } + + aop->type = AOP_PAIRPTR; + aop->aopu.aop_pairId = id; + _G.pairs[id].offset = 0; + _G.pairs[id].last_type = aop->type; +} + +static void +setupToPreserveCarry (asmop *result, asmop *left, asmop *right) +{ + wassert (left && right); + + if (IS_Z80) + { + if (couldDestroyCarry (right) && couldDestroyCarry (result)) + { + shiftIntoPair (0, right); + shiftIntoPair (1, result); + } + else if (couldDestroyCarry (right)) + { + shiftIntoPair (0, right); + } + else if (couldDestroyCarry (result)) + { + shiftIntoPair (0, result); + } + else + { + /* Fine */ + } + } +} + /*-----------------------------------------------------------------*/ /* genPlus - generates code for addition */ /*-----------------------------------------------------------------*/ @@ -2813,7 +3215,7 @@ genPlus (iCode * ic) AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY) { /* Cant happen */ - wassert (0); + wassertl (0, "Tried to add two bits"); } /* if left in bit space & right literal */ @@ -2821,7 +3223,7 @@ genPlus (iCode * ic) AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT) { /* Can happen I guess */ - wassert (0); + wassertl (0, "Tried to add a bit to a literal"); } /* if I can do an increment instead @@ -2852,12 +3254,48 @@ genPlus (iCode * ic) } } - if (isPair (AOP (IC_RIGHT (ic))) && getPairId (AOP (IC_RESULT (ic))) == PAIR_HL) + if ((isPair (AOP (IC_RIGHT (ic))) || isPair (AOP (IC_LEFT (ic)))) && getPairId (AOP (IC_RESULT (ic))) == PAIR_HL) { /* Fetch into HL then do the add */ + PAIR_ID left = getPairId (AOP (IC_LEFT (ic))); + PAIR_ID right = getPairId (AOP (IC_RIGHT (ic))); + spillPair (PAIR_HL); + + if (left == PAIR_HL && right != PAIR_INVALID) + { + emit2 ("add hl,%s", _pairs[right].name); + goto release; + } + else if (right == PAIR_HL && left != PAIR_INVALID) + { + emit2 ("add hl,%s", _pairs[left].name); + goto release; + } + else if (right != PAIR_INVALID && right != PAIR_HL) + { + fetchPair (PAIR_HL, AOP (IC_LEFT (ic))); + emit2 ("add hl,%s", getPairName (AOP (IC_RIGHT (ic)))); + goto release; + } + else if (left != PAIR_INVALID && left != PAIR_HL) + { + fetchPair (PAIR_HL, AOP (IC_RIGHT (ic))); + emit2 ("add hl,%s", getPairName (AOP (IC_LEFT (ic)))); + goto release; + } + else + { + /* Can't do it */ + } + } + + if (isPair (AOP (IC_RIGHT (ic))) && AOP_TYPE (IC_LEFT (ic)) == AOP_IMMD && getPairId (AOP (IC_RIGHT (ic))) != PAIR_HL) + { fetchPair (PAIR_HL, AOP (IC_LEFT (ic))); - emit2 ("add hl,%s", getPairName (AOP (IC_RIGHT (ic)))); + emit2 ("add hl,%s ; 2", getPairName (AOP (IC_RIGHT (ic)))); + spillCached(); + commitPair ( AOP (IC_RESULT (ic)), PAIR_HL); goto release; } @@ -2932,6 +3370,8 @@ genPlus (iCode * ic) } } + setupToPreserveCarry (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)), AOP (IC_RIGHT (ic))); + while (size--) { if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC) @@ -2997,8 +3437,7 @@ genMinusDec (iCode * ic) /* 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); + movLeft2ResultLong (IC_LEFT (ic), 0, IC_RESULT (ic), 0, 0, 2); while (icount--) emit2 ("dec %s", getPairName (AOP (IC_RESULT (ic)))); return TRUE; @@ -3056,7 +3495,7 @@ genMinus (iCode * ic) if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY && AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to subtract two bits"); goto release; } @@ -3110,7 +3549,10 @@ genMinus (iCode * ic) emit2 ("ld a,%s", _pairs[left].h); emit2 ("sbc a,%s", _pairs[right].h); - aopPut (AOP (IC_RESULT (ic)), "a", 1); + if ( AOP_SIZE (IC_RESULT (ic)) > 1) + { + aopPut (AOP (IC_RESULT (ic)), "a", 1); + } aopPut (AOP (IC_RESULT (ic)), "e", 0); goto release; } @@ -3125,6 +3567,8 @@ genMinus (iCode * ic) } } + setupToPreserveCarry (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)), AOP (IC_RIGHT (ic))); + /* if literal, add a,#-lit, else normal subb */ while (size--) { @@ -3152,7 +3596,9 @@ genMinus (iCode * ic) if (AOP_SIZE (IC_RESULT (ic)) == 3 && AOP_SIZE (IC_LEFT (ic)) == 3 && !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) - wassert (0); + { + wassertl (0, "Tried to subtract on a long pointer"); + } release: freeAsmop (IC_LEFT (ic), NULL, ic); @@ -3166,8 +3612,92 @@ release: static void genMult (iCode * ic) { + int val; + int count, i; + /* If true then the final operation should be a subtract */ + bool active = FALSE; + /* Shouldn't occur - all done through function calls */ - wassert (0); + aopOp (IC_LEFT (ic), ic, FALSE, FALSE); + aopOp (IC_RIGHT (ic), ic, FALSE, FALSE); + aopOp (IC_RESULT (ic), ic, TRUE, FALSE); + + if (AOP_SIZE (IC_LEFT (ic)) > 2 || + AOP_SIZE (IC_RIGHT (ic)) > 2 || + AOP_SIZE (IC_RESULT (ic)) > 2) + { + wassertl (0, "Multiplication is handled through support function calls"); + } + + /* Swap left and right such that right is a literal */ + if ((AOP_TYPE (IC_LEFT (ic)) == AOP_LIT)) + { + operand *t = IC_RIGHT (ic); + IC_RIGHT (ic) = IC_LEFT (ic); + IC_LEFT (ic) = t; + } + + wassertl (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT, "Right must be a literal"); + + val = (int)floatFromVal ( AOP (IC_RIGHT (ic))->aopu.aop_lit); + // wassertl (val > 0, "Multiply must be positive"); + wassertl (val != 1, "Can't multiply by 1"); + + if (IS_Z80) { + _push (PAIR_DE); + } + + if ( AOP_SIZE (IC_LEFT (ic)) == 1 && !SPEC_USIGN (getSpec (operandType ( IC_LEFT (ic))))) + { + emit2 ("ld e,%s", aopGet (AOP (IC_LEFT (ic)), LSB, FALSE)); + emit2 ("ld a,e"); + emit2 ("rlc a"); + emit2 ("sbc a,a"); + emit2 ("ld d,a"); + } + else + { + fetchPair (PAIR_DE, AOP (IC_LEFT (ic))); + } + + i = val; + + /* Fully unroled version of mul.s. Not the most efficient. + */ + for (count = 0; count < 16; count++) + { + if (count != 0 && active) + { + emit2 ("add hl,hl"); + } + if (i & 0x8000U) + { + if (active == FALSE) + { + emit2 ("ld l,e"); + emit2 ("ld h,d"); + } + else + { + emit2 ("add hl,de"); + } + active = TRUE; + } + i <<= 1; + } + + spillCached(); + + if (IS_Z80) + { + _pop (PAIR_DE); + } + + commitPair ( AOP (IC_RESULT (ic)), PAIR_HL); + + freeAsmop (IC_LEFT (ic), NULL, ic); + freeAsmop (IC_RIGHT (ic), NULL, ic); + freeAsmop (IC_RESULT (ic), NULL, ic); } /*-----------------------------------------------------------------*/ @@ -3177,7 +3707,7 @@ static void genDiv (iCode * ic) { /* Shouldn't occur - all done through function calls */ - wassert (0); + wassertl (0, "Division is handled through support function calls"); } /*-----------------------------------------------------------------*/ @@ -3216,6 +3746,14 @@ genIfxJump (iCode * ic, char *jval) { inst = "nc"; } + else if (!strcmp (jval, "m")) + { + inst = "m"; + } + else if (!strcmp (jval, "p")) + { + inst = "p"; + } else { /* The buffer contains the bit on A that we should test */ @@ -3238,6 +3776,14 @@ genIfxJump (iCode * ic, char *jval) { inst = "c"; } + else if (!strcmp (jval, "m")) + { + inst = "p"; + } + else if (!strcmp (jval, "p")) + { + inst = "m"; + } else { /* The buffer contains the bit on A that we should test */ @@ -3255,6 +3801,12 @@ genIfxJump (iCode * ic, char *jval) else if (!strcmp (jval, "nc")) { } + else if (!strcmp (jval, "m")) + { + } + else if (!strcmp (jval, "p")) + { + } else { emit2 ("bit %s,a", jval); @@ -3273,30 +3825,7 @@ _getPairIdName (PAIR_ID id) } #endif -/** Generic compare for > or < - */ -static void -genCmp (operand * left, operand * right, - operand * result, iCode * ifx, int sign) -{ - int size, offset = 0; - unsigned long lit = 0L; - bool swap_sense = FALSE; - - /* if left & right are bit variables */ - if (AOP_TYPE (left) == AOP_CRY && - AOP_TYPE (right) == AOP_CRY) - { - /* Cant happen on the Z80 */ - wassert (0); - } - else - { - /* subtract right from left if at the - end the carry flag is set then we know that - left is greater than right */ - size = max (AOP_SIZE (left), AOP_SIZE (right)); - +#if OLD /* if unsigned char cmp with lit, just compare */ if ((size == 1) && (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR)) @@ -3351,51 +3880,45 @@ genCmp (operand * left, operand * right, } spillPair (PAIR_HL); } + else if (size == 4 && IS_Z80 && couldDestroyCarry(AOP(right)) && couldDestroyCarry(AOP(left))) + { + setupPair (PAIR_HL, AOP (left), 0); + aopGet (AOP(right), LSB, FALSE); + + while (size--) + { + if (size == 0 && sign) + { + // Highest byte when signed needs the bits flipped + // Save the flags + emit2 ("push af"); + emit2 ("ld a,(hl)"); + emit2 ("xor #0x80"); + emit2 ("ld l,a"); + emit2 ("ld a,%d(iy)", offset); + emit2 ("xor #0x80"); + emit2 ("ld h,a"); + emit2 ("pop af"); + emit2 ("ld a,l"); + emit2 ("%s a,h", offset == 0 ? "sub" : "sbc"); + } + else + { + emit2 ("ld a,(hl)"); + emit2 ("%s a,%d(iy)", offset == 0 ? "sub" : "sbc", offset); + } + + if (size != 0) + { + emit2 ("inc hl"); + } + offset++; + } + spillPair (PAIR_HL); + spillPair (PAIR_IY); + } else { -#if 0 - // PENDING: Doesn't work around zero - - /* Special cases: - On the GB: - If the left or the right is a lit: - Load -lit into HL, add to right via, check sense. - */ - if (IS_GB && size == 2 && (AOP_TYPE (right) == AOP_LIT || AOP_TYPE (left) == AOP_LIT)) - { - PAIR_ID id = PAIR_DE; - asmop *lit = AOP (right); - asmop *op = AOP (left); - swap_sense = TRUE; - - if (AOP_TYPE (left) == AOP_LIT) - { - swap_sense = FALSE; - lit = AOP (left); - op = AOP (right); - } - if (sign) - { - emit2 ("ld e,%s", aopGet (op, 0, 0)); - emit2 ("ld a,%s", aopGet (op, 1, 0)); - emit2 ("xor a,!immedbyte", 0x80); - emit2 ("ld d,a"); - } - else - { - id = getPairId (op); - if (id == PAIR_INVALID) - { - fetchPair (PAIR_DE, op); - id = PAIR_DE; - } - } - spillPair (PAIR_HL); - emit2 ("ld hl,%s", fetchLitSpecial (lit, TRUE, sign)); - emit2 ("add hl,%s", _getPairIdName (id)); - goto release; - } -#endif if (AOP_TYPE (right) == AOP_LIT) { lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); @@ -3422,6 +3945,7 @@ genCmp (operand * left, operand * right, goto release; } } + if (sign) { /* First setup h and l contaning the top most bytes XORed */ @@ -3470,15 +3994,115 @@ genCmp (operand * left, operand * right, else { /* Subtract through, propagating the carry */ - emit2 ("%s a,%s", offset == 0 ? "sub" : "sbc", aopGet (AOP (right), offset++, FALSE)); + emit2 ("%s a,%s", offset == 0 ? "sub" : "sbc", aopGet (AOP (right), offset, FALSE)); + offset++; } } } } +#endif + +/** Generic compare for > or < + */ +static void +genCmp (operand * left, operand * right, + operand * result, iCode * ifx, int sign) +{ + int size, offset = 0; + unsigned long lit = 0L; + bool swap_sense = FALSE; + + /* if left & right are bit variables */ + if (AOP_TYPE (left) == AOP_CRY && + AOP_TYPE (right) == AOP_CRY) + { + /* Cant happen on the Z80 */ + wassertl (0, "Tried to compare two bits"); + } + else + { + /* Do a long subtract of right from left. */ + size = max (AOP_SIZE (left), AOP_SIZE (right)); + + if (size > 1 && IS_GB && requiresHL(AOP(right)) && requiresHL(AOP(left))) + { + // On the Gameboy we can't afford to adjust HL as it may trash the carry. + // Pull left into DE and right into HL + aopGet (AOP(left), LSB, FALSE); + emit2 ("ld d,h"); + emit2 ("ld e,l"); + aopGet (AOP(right), LSB, FALSE); + + while (size--) + { + emit2 ("ld a,(de)"); + emit2 ("%s a,(hl)", offset == 0 ? "sub" : "sbc"); + + if (size != 0) + { + emit2 ("inc hl"); + emit2 ("inc de"); + } + offset++; + } + spillPair (PAIR_HL); + goto release; + } + + if (AOP_TYPE (right) == AOP_LIT) + { + lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + /* optimize if(x < 0) or if(x >= 0) */ + if (lit == 0) + { + if (!sign) + { + /* No sign so it's always false */ + _clearCarry(); + } + else + { + /* Just load in the top most bit */ + _moveA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE)); + if (!(AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) && ifx) + { + genIfxJump (ifx, "7"); + return; + } + else + { + if (!sign) + { + emit2 ("rlc a"); + } + if (ifx) + { + genIfxJump (ifx, swap_sense ? "c" : "nc"); + return; + } + } + } + goto release; + } + } + + while (size--) + { + _moveA (aopGet (AOP (left), offset, FALSE)); + /* Subtract through, propagating the carry */ + emit2 ("%s a,%s", offset == 0 ? "sub" : "sbc", aopGet (AOP (right), offset, FALSE)); + offset++; + } + } release: if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) { + if (sign) + { + /* Shift the sign bit up into carry */ + emit2 ("rlca"); + } outBitCLong (result, swap_sense); } else @@ -3487,9 +4111,33 @@ release: ifx conditional branch then generate code a little differently */ if (ifx) - genIfxJump (ifx, swap_sense ? "nc" : "c"); + { + if (sign) + { + if (IS_GB) + { + emit2 ("rlca"); + genIfxJump (ifx, swap_sense ? "nc" : "c"); + } + else + { + genIfxJump (ifx, swap_sense ? "p" : "m"); + } + } + else + { + genIfxJump (ifx, swap_sense ? "nc" : "c"); + } + } else - outBitCLong (result, swap_sense); + { + if (sign) + { + /* Shift the sign bit up into carry */ + emit2 ("rlca"); + } + outBitCLong (result, swap_sense); + } /* leave the result in acc */ } } @@ -3583,11 +4231,9 @@ gencjneshort (operand * left, operand * right, symbol * lbl) emit2 ("ld a,%s", aopGet (AOP (left), offset, FALSE)); if (size > 1) { - size--; - offset++; - while (size--) + while (--size) { - emit2 ("or a,%s", aopGet (AOP (left), offset, FALSE)); + emit2 ("or a,%s", aopGet (AOP (left), ++offset, FALSE)); } } else @@ -3675,7 +4321,7 @@ genCmpEq (iCode * ic, iCode * ifx) aopOp ((right = IC_RIGHT (ic)), ic, FALSE, FALSE); aopOp ((result = IC_RESULT (ic)), ic, TRUE, FALSE); - emitDebug ("; genCmpEq: left %u, right %u, result %u\n", AOP_SIZE(IC_LEFT(ic)), AOP_SIZE(IC_RIGHT(ic)), AOP_SIZE(IC_RESULT(ic))); + emitDebug ("; genCmpEq: left %u, right %u, result %u", AOP_SIZE(IC_LEFT(ic)), AOP_SIZE(IC_RIGHT(ic)), AOP_SIZE(IC_RESULT(ic))); /* Swap operands if it makes the operation easier. ie if: 1. Left is a literal. @@ -3694,14 +4340,16 @@ genCmpEq (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_CRY && ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT))) { - wassert (0); + wassertl (0, "Tried to compare two bits"); } else { tlbl = newiTempLabel (NULL); + emitDebug(";1"); gencjneshort (left, right, tlbl); if (IC_TRUE (ifx)) { + emitDebug(";2"); emit2 ("jp !tlabel", IC_TRUE (ifx)->key + 100); emitLabel (tlbl->key + 100); } @@ -3709,6 +4357,7 @@ genCmpEq (iCode * ic, iCode * ifx) { /* PENDING: do this better */ symbol *lbl = newiTempLabel (NULL); + emitDebug(";3"); emit2 ("!shortjp !tlabel", lbl->key + 100); emitLabel (tlbl->key + 100); emit2 ("jp !tlabel", IC_FALSE (ifx)->key + 100); @@ -3724,10 +4373,12 @@ genCmpEq (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_CRY && ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT))) { - wassert (0); + wassertl (0, "Tried to compare a bit to either a literal or another bit"); } else { + emitDebug(";4"); + gencjne (left, right, newiTempLabel (NULL)); if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) { @@ -3735,6 +4386,7 @@ genCmpEq (iCode * ic, iCode * ifx) } if (ifx) { + emitDebug(";5"); genIfxJump (ifx, "a"); goto release; } @@ -3742,6 +4394,7 @@ genCmpEq (iCode * ic, iCode * ifx) then put the result in place */ if (AOP_TYPE (result) != AOP_CRY) { + emitDebug(";6"); outAcc (result); } /* leave the result in acc */ @@ -3795,7 +4448,7 @@ genAndOp (iCode * ic) if (AOP_TYPE (left) == AOP_CRY && AOP_TYPE (right) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to and two bits"); } else { @@ -3832,7 +4485,7 @@ genOrOp (iCode * ic) if (AOP_TYPE (left) == AOP_CRY && AOP_TYPE (right) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to OR two bits"); } else { @@ -3909,15 +4562,6 @@ genAnd (iCode * ic, iCode * ifx) aopOp ((right = IC_RIGHT (ic)), ic, FALSE, FALSE); aopOp ((result = IC_RESULT (ic)), ic, TRUE, FALSE); -#ifdef DEBUG_TYPE - emitDebug ("; Type res[%d] = l[%d]&r[%d]", - AOP_TYPE (result), - AOP_TYPE (left), AOP_TYPE (right)); - emitDebug ("; Size res[%d] = l[%d]&r[%d]", - AOP_SIZE (result), - AOP_SIZE (left), AOP_SIZE (right)); -#endif - /* if left is a literal & right is not then exchange them */ if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) || AOP_NEEDSACC (left)) @@ -3950,7 +4594,7 @@ genAnd (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to perform an AND with a bit as an operand"); goto release; } @@ -3960,80 +4604,46 @@ genAnd (iCode * ic, iCode * ifx) (AOP_TYPE (result) == AOP_CRY) && (AOP_TYPE (left) != AOP_CRY)) { - int posbit = isLiteralBit (lit); - /* left & 2^n */ - if (posbit) - { - posbit--; - _moveA (aopGet (AOP (left), posbit >> 3, FALSE)); - // bit = left & 2^n - if (size) - { - wassert (0); - emit2 ("mov c,acc.%d", posbit & 0x07); - } - // if(left & 2^n) - else - { - if (ifx) - { - sprintf (buffer, "%d", posbit & 0x07); - genIfxJump (ifx, buffer); - } - else - { - wassert (0); - } - goto release; - } - } - else - { - symbol *tlbl = newiTempLabel (NULL); - int sizel = AOP_SIZE (left); - if (size) - { - wassert (0); - emit2 ("setb c"); - } - while (sizel--) - { - if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L) - { - _moveA (aopGet (AOP (left), offset, FALSE)); - // byte == 2^n ? - if ((posbit = isLiteralBit (bytelit)) != 0) - { - wassert (0); - emit2 ("jb acc.%d,%05d$", (posbit - 1) & 0x07, tlbl->key + 100); - } - else - { - if (bytelit != 0x0FFL) - emit2 ("and a,%s", - aopGet (AOP (right), offset, FALSE)); - else - /* For the flags */ - emit2 ("or a,a"); - emit2 ("!shortjp nz,!tlabel", tlbl->key + 100); - } - } + symbol *tlbl = newiTempLabel (NULL); + int sizel = AOP_SIZE (left); + if (size) + { + /* PENDING: Test case for this. */ + emit2 ("scf"); + } + while (sizel--) + { + if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L) + { + _moveA (aopGet (AOP (left), offset, FALSE)); + if (bytelit != 0x0FFL) + { + emit2 ("and a,%s", aopGet (AOP (right), offset, FALSE)); + } + else + { + /* For the flags */ + emit2 ("or a,a"); + } + emit2 ("!shortjp nz,!tlabel", tlbl->key + 100); + } offset++; - } - // bit = left & literal - if (size) - { - emit2 ("clr c"); - emit2 ("!tlabeldef", tlbl->key + 100); - } - // if(left & literal) - else - { - if (ifx) - jmpTrueOrFalse (ifx, tlbl); - goto release; - } - } + } + // bit = left & literal + if (size) + { + emit2 ("clr c"); + emit2 ("!tlabeldef", tlbl->key + 100); + } + // if(left & literal) + else + { + if (ifx) + { + jmpTrueOrFalse (ifx, tlbl); + } + goto release; + } outBitC (result); goto release; } @@ -4065,7 +4675,7 @@ genAnd (iCode * ic, iCode * ifx) { if (AOP_TYPE (left) == AOP_ACC) { - wassert (0); + wassertl (0, "Tried to perform an AND where the left operand is allocated into A"); } else { @@ -4082,7 +4692,7 @@ genAnd (iCode * ic, iCode * ifx) // left & result in different registers if (AOP_TYPE (result) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to AND where the result is in carry"); } else { @@ -4136,20 +4746,12 @@ genOr (iCode * ic, iCode * ifx) operand *left, *right, *result; int size, offset = 0; unsigned long lit = 0L; + int bytelit = 0; aopOp ((left = IC_LEFT (ic)), ic, FALSE, FALSE); aopOp ((right = IC_RIGHT (ic)), ic, FALSE, FALSE); aopOp ((result = IC_RESULT (ic)), ic, TRUE, FALSE); -#if 1 - emitDebug ("; Type res[%d] = l[%d]&r[%d]", - AOP_TYPE (result), - AOP_TYPE (left), AOP_TYPE (right)); - emitDebug ("; Size res[%d] = l[%d]&r[%d]", - AOP_SIZE (result), - AOP_SIZE (left), AOP_SIZE (right)); -#endif - /* if left is a literal & right is not then exchange them */ if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) || AOP_NEEDSACC (left)) @@ -4182,15 +4784,39 @@ genOr (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to OR where left is a bit"); goto release; } + // if(val | 0xZZ) - size = 0, ifx != FALSE - + // bit = val | 0xZZ - size = 1, ifx = FALSE - if ((AOP_TYPE (right) == AOP_LIT) && (AOP_TYPE (result) == AOP_CRY) && (AOP_TYPE (left) != AOP_CRY)) { - wassert (0); + symbol *tlbl = newiTempLabel (NULL); + int sizel = AOP_SIZE (left); + + if (size) + { + wassertl (0, "Result is assigned to a bit"); + } + /* PENDING: Modeled after the AND code which is inefficent. */ + while (sizel--) + { + bytelit = (lit >> (offset * 8)) & 0x0FFL; + + _moveA (aopGet (AOP (left), offset, FALSE)); + /* OR with any literal is the same as OR with itself. */ + emit2 ("or a,a"); + emit2 ("!shortjp nz,!tlabel", tlbl->key + 100); + + offset++; + } + if (ifx) + { + jmpTrueOrFalse (ifx, tlbl); + } goto release; } @@ -4230,7 +4856,7 @@ genOr (iCode * ic, iCode * ifx) // left & result in different registers if (AOP_TYPE (result) == AOP_CRY) { - wassert (0); + wassertl (0, "Result of OR is in a bit"); } else for (; (size--); offset++) @@ -4316,15 +4942,39 @@ genXor (iCode * ic, iCode * ifx) if (AOP_TYPE (left) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to XOR a bit"); goto release; } + // if(val & 0xZZ) - size = 0, ifx != FALSE - + // bit = val & 0xZZ - size = 1, ifx = FALSE - if ((AOP_TYPE (right) == AOP_LIT) && (AOP_TYPE (result) == AOP_CRY) && (AOP_TYPE (left) != AOP_CRY)) { - wassert (0); + symbol *tlbl = newiTempLabel (NULL); + int sizel = AOP_SIZE (left); + + if (size) + { + /* PENDING: Test case for this. */ + wassertl (0, "Tried to XOR left against a literal with the result going into a bit"); + } + while (sizel--) + { + _moveA (aopGet (AOP (left), offset, FALSE)); + emit2 ("xor a,%s", aopGet (AOP (right), offset, FALSE)); + emit2 ("!shortjp nz,!tlabel", tlbl->key + 100); + offset++; + } + if (ifx) + { + jmpTrueOrFalse (ifx, tlbl); + } + else + { + wassertl (0, "Result of XOR was destined for a bit"); + } goto release; } @@ -4366,7 +5016,7 @@ genXor (iCode * ic, iCode * ifx) // left & result in different registers if (AOP_TYPE (result) == AOP_CRY) { - wassert (0); + wassertl (0, "Result of XOR is in a bit"); } else for (; (size--); offset++) @@ -4538,7 +5188,7 @@ shiftR2Left2Result (operand * left, int offl, tlbl1 = newiTempLabel (NULL); /* Left is already in result - so now do the shift */ - if (shCount <= 2) + if (shCount <= 4) { while (shCount--) { @@ -4733,7 +5383,7 @@ genlshTwo (operand * result, operand * left, int shCount) { movLeft2Result (left, LSB, result, MSB16, 0); aopPut (AOP (result), "!zero", 0); - shiftL1Left2Result (left, MSB16, result, MSB16, shCount); + shiftL1Left2Result (left, LSB, result, MSB16, shCount); } else { @@ -4788,11 +5438,6 @@ genLeftShiftLiteral (operand * left, size = getSize (operandType (result)); -#if VIEW_SIZE - emitDebug ("; shift left result %d, left %d", size, - AOP_SIZE (left)); -#endif - /* I suppose that the left size >= result size */ if (shCount == 0) { @@ -4864,7 +5509,7 @@ genLeftShift (iCode * ic) /* now move the left to the result if they are not the same */ -#if 1 + if (!sameRegs (AOP (left), AOP (result))) { @@ -4877,17 +5522,6 @@ genLeftShift (iCode * ic) offset++; } } -#else - size = AOP_SIZE (result); - offset = 0; - while (size--) - { - l = aopGet (AOP (left), offset, FALSE); - aopPut (AOP (result), l, offset); - offset++; - } -#endif - tlbl = newiTempLabel (NULL); size = AOP_SIZE (result); @@ -4935,8 +5569,6 @@ genrshOne (operand * result, operand * left, int shCount, int is_signed) l = aopGet (AOP (left), 0, FALSE); - emit2 ("or a,a"); - if (AOP (result)->type == AOP_REG) { aopPut (AOP (result), l, 0); @@ -4988,7 +5620,10 @@ shiftR1Left2Result (operand * left, int offl, _moveA (aopGet (AOP (left), offl, FALSE)); if (sign) { - wassert (0); + while (shCount--) + { + emit2 ("%s a", sign ? "sra" : "srl"); + } } else { @@ -5017,7 +5652,19 @@ genrshTwo (operand * result, operand * left, { movLeft2Result (left, MSB16, result, LSB, sign); } - aopPut (AOP (result), "!zero", 1); + if (sign) + { + /* Sign extend the result */ + _moveA(aopGet (AOP (result), 0, FALSE)); + emit2 ("rlc a"); + emit2 ("sbc a,a"); + + aopPut (AOP (result), ACC_NAME, MSB16); + } + else + { + aopPut (AOP (result), "!zero", 1); + } } /* 1 <= shCount <= 7 */ else @@ -5046,9 +5693,6 @@ genRightShiftLiteral (operand * left, size = getSize (operandType (result)); - emitDebug ("; shift right result %d, left %d", size, - AOP_SIZE (left)); - /* I suppose that the left size >= result size */ if (shCount == 0) { @@ -5066,7 +5710,6 @@ genRightShiftLiteral (operand * left, genrshOne (result, left, shCount, sign); break; case 2: - /* PENDING: sign support */ genrshTwo (result, left, shCount, sign); break; case 4: @@ -5189,7 +5832,9 @@ genGenPointerGet (operand * left, aopOp (left, ic, FALSE, FALSE); aopOp (result, ic, FALSE, FALSE); - if (isPair (AOP (left)) && AOP_SIZE (result) == 1) + size = AOP_SIZE (result); + + if (isPair (AOP (left)) && size == 1) { /* Just do it */ if (isPtrPair (AOP (left))) @@ -5206,11 +5851,24 @@ genGenPointerGet (operand * left, goto release; } + if ( getPairId( AOP (left)) == PAIR_IY) + { + /* Just do it */ + offset = 0; + while (size--) + { + char at[20]; + tsprintf (at, "!*iyx", offset); + aopPut (AOP (result), at, offset); + offset++; + } + goto release; + } + /* For now we always load into IY */ /* if this is remateriazable */ fetchPair (pair, AOP (left)); - /* so iy now contains the address */ freeAsmop (left, NULL, ic); /* if bit then unpack */ @@ -5218,6 +5876,14 @@ genGenPointerGet (operand * left, { wassert (0); } + else if ( getPairId( AOP (result)) == PAIR_HL) + { + wassertl (size == 2, "HL must be of size 2"); + emit2 ("ld a,!*hl"); + emit2 ("inc hl"); + emit2 ("ld h,!*hl"); + emit2 ("ld l,a"); + } else { size = AOP_SIZE (result); @@ -5270,7 +5936,7 @@ genPointerGet (iCode * ic) bool isRegOrLit (asmop * aop) { - if (aop->type == AOP_REG || aop->type == AOP_LIT || aop->type == AOP_IMMD) + if (aop->type == AOP_REG || aop->type == AOP_LIT || aop->type == AOP_IMMD || aop->type == AOP_HLREG) return TRUE; return FALSE; } @@ -5285,15 +5951,17 @@ genGenPointerSet (operand * right, int size, offset; sym_link *retype = getSpec (operandType (right)); PAIR_ID pairId = PAIR_HL; - + aopOp (result, ic, FALSE, FALSE); aopOp (right, ic, FALSE, FALSE); if (IS_GB) pairId = PAIR_DE; + size = AOP_SIZE (right); + /* Handle the exceptions first */ - if (isPair (AOP (result)) && (AOP_SIZE (right) == 1)) + if (isPair (AOP (result)) && size == 1) { /* Just do it */ const char *l = aopGet (AOP (right), 0, FALSE); @@ -5309,6 +5977,28 @@ genGenPointerSet (operand * right, } goto release; } + + if ( getPairId( AOP (result)) == PAIR_IY) + { + /* Just do it */ + const char *l = aopGet (AOP (right), 0, FALSE); + + offset = 0; + while (size--) + { + if (canAssignToPtr (l)) + { + emit2 ("ld !*iyx,%s", offset, aopGet( AOP(right), offset, FALSE)); + } + else + { + _moveA (aopGet (AOP (right), offset, FALSE)); + emit2 ("ld !*iyx,a", offset); + } + offset++; + } + goto release; + } /* if the operand is already in dptr then we do nothing else we move the value to dptr */ @@ -5326,7 +6016,6 @@ genGenPointerSet (operand * right, } else { - size = AOP_SIZE (right); offset = 0; while (size--) @@ -5428,21 +6117,19 @@ genAddrOf (iCode * ic) spillCached (); if (sym->stack <= 0) { - emit2 ("!ldahlsp", sym->stack + _G.stack.pushed + _G.stack.offset); + setupPairFromSP (PAIR_HL, sym->stack + _G.stack.pushed + _G.stack.offset); } else { - emit2 ("!ldahlsp", sym->stack + _G.stack.pushed + _G.stack.offset + _G.stack.param_offset); + setupPairFromSP (PAIR_HL, sym->stack + _G.stack.pushed + _G.stack.offset + _G.stack.param_offset); } - emit2 ("ld d,h"); - emit2 ("ld e,l"); + commitPair (AOP (IC_RESULT (ic)), PAIR_HL); } else { emit2 ("ld de,!hashedstr", sym->rname); + commitPair (AOP (IC_RESULT (ic)), PAIR_DE); } - aopPut (AOP (IC_RESULT (ic)), "e", 0); - aopPut (AOP (IC_RESULT (ic)), "d", 1); } else { @@ -5460,8 +6147,7 @@ genAddrOf (iCode * ic) { emit2 ("ld hl,#%s", sym->rname); } - aopPut (AOP (IC_RESULT (ic)), "l", 0); - aopPut (AOP (IC_RESULT (ic)), "h", 1); + commitPair (AOP (IC_RESULT (ic)), PAIR_HL); } freeAsmop (IC_RESULT (ic), NULL, ic); } @@ -5479,14 +6165,12 @@ genAssign (iCode * ic) result = IC_RESULT (ic); right = IC_RIGHT (ic); -#if 1 /* Dont bother assigning if they are the same */ if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic))) { emitDebug ("; (operands are equal %u)", operandsEqu (IC_RESULT (ic), IC_RIGHT (ic))); return; } -#endif aopOp (right, ic, FALSE, FALSE); aopOp (result, ic, TRUE, FALSE); @@ -5501,7 +6185,7 @@ genAssign (iCode * ic) /* if the result is a bit */ if (AOP_TYPE (result) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to assign to a bit"); } /* general case */ @@ -5509,7 +6193,10 @@ genAssign (iCode * ic) offset = 0; if (AOP_TYPE (right) == AOP_LIT) + { lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + } + if (isPair (AOP (result))) { fetchPair (getPairId (AOP (result)), AOP (right)); @@ -5550,6 +6237,12 @@ genAssign (iCode * ic) offset++; } } + else if (size == 2 && AOP_TYPE (right) == AOP_IY) + { + emit2 ("ld hl,(%s)", AOP (right)->aopu.aop_dir); + aopPut (AOP (result), "l", LSB); + aopPut (AOP (result), "h", MSB16); + } else if (size == 2 && requiresHL (AOP (right)) && requiresHL (AOP (result)) && IS_GB) { /* Special case. Load into a and d, then load out. */ @@ -5585,7 +6278,7 @@ genAssign (iCode * ic) while (size--) { /* PENDING: do this check better */ - if (requiresHL (AOP (right)) && requiresHL (AOP (result))) + if (IS_GB && requiresHL (AOP (right)) && requiresHL (AOP (result))) { _moveA (aopGet (AOP (right), offset, FALSE)); aopPut (AOP (result), "a", offset); @@ -5657,7 +6350,7 @@ genCast (iCode * ic) /* if the result is a bit */ if (AOP_TYPE (result) == AOP_CRY) { - wassert (0); + wassertl (0, "Tried to cast to a bit"); } /* if they are the same size : or less */ @@ -5681,16 +6374,7 @@ genCast (iCode * ic) goto release; } - /* PENDING: should be OK. */ -#if 0 - /* if the result is of type pointer */ - if (IS_PTR (ctype)) - { - wassert (0); - } -#endif - - /* so we now know that the size of destination is greater + /* So we now know that the size of destination is greater than the size of the source */ /* we move to result for the size of source */ size = AOP_SIZE (right); @@ -5717,7 +6401,6 @@ genCast (iCode * ic) const char *l = aopGet (AOP (right), AOP_SIZE (right) - 1, FALSE); _moveA (l); - emitDebug ("; genCast: sign extend untested."); emit2 ("rla "); emit2 ("sbc a,a"); while (size--) @@ -5942,16 +6625,10 @@ genArrayInit (iCode * ic) aopOp (IC_LEFT(ic), ic, FALSE, FALSE); - if (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) - { - /* Emit the support function call and the destination address. */ - emit2("call __initrleblock"); - emit2(".dw %s", aopGetWord (AOP(IC_LEFT(ic)), 0)); - } - else - { - wassertl (0, "Unexpected operand to genArrayInit.\n"); - } + _saveRegsForCall(ic, 0); + + fetchPair (PAIR_HL, AOP (IC_LEFT (ic))); + emit2 ("call __initrleblock"); type = operandType(IC_LEFT(ic)); @@ -5995,6 +6672,10 @@ genArrayInit (iCode * ic) /* Mark the end of the run. */ emit2(".db 0"); + _restoreRegsAfterCall(); + + spillCached (); + freeAsmop (IC_LEFT(ic), NULL, ic); } @@ -6007,7 +6688,7 @@ genZ80Code (iCode * lic) iCode *ic; int cln = 0; - /* HACK */ + /* Hack */ if (IS_GB) { _fReturn = _gbz80_return; @@ -6270,13 +6951,12 @@ genZ80Code (iCode * lic) break; case ARRAYINIT: - genArrayInit(ic); - break; + emitDebug ("; genArrayInit"); + genArrayInit(ic); + break; default: ic = ic; - /* piCode(ic,stdout); */ - } } @@ -6300,6 +6980,9 @@ genZ80Code (iCode * lic) } codeOutFile = fp; } + + freeTrace(&_G.lines.trace); + freeTrace(&_G.trace.aops); } /* @@ -6340,7 +7023,7 @@ fetchLitSpecial (asmop * aop, bool negate, bool xor) v &= 0xFFFF; tsprintf (buffer, "!immedword", v); - return gc_strdup (buffer); + return traceAlloc(&_G.trace.aops, Safe_strdup (buffer)); }