#include <string.h>
#include <ctype.h>
-#include <common.h>
+#include "common.h"
#include "ralloc.h"
#include "gen.h"
#include "SDCCglobl.h"
#define BETTER_LITERAL_SHIFT
char *aopLiteral (value * val, int offset);
+extern int allocInfo;
/* 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 */
-static char *zero = "#0x00";
-static char *one = "#0x01";
+static char *zero = "#0";
+static char *one = "#1";
static char *spname;
#define D(x) x
static char **fReturn = fReturn24;
static char *accUse[] =
{"a", "b"};
-
+static char *dptrn[2][3];
+static char *javaRet[] = { "r0","r1","r2","r3"};
static short rbank = -1;
static struct
short r0Pushed;
short r1Pushed;
short accInUse;
+ short bInUse;
short inLine;
short debugLine;
short nRegsSaved;
+ short dptrInUse;
+ short dptr1InUse;
set *sendSet;
}
_G;
+static char *rb1regs[] = {
+ "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7"
+};
+
static void saveRBank (int, iCode *, bool);
#define RESULTONSTACK(x) \
// A scratch register which will be used to hold
// result bytes from operands in far space via DPTR2.
-#define DP2_RESULT_REG "ap"
+#define DP2_RESULT_REG "_ap"
static lineNode *lineHead = NULL;
static lineNode *lineCurr = NULL;
#define MSB16 1
#define MSB24 2
#define MSB32 3
+#define PROTECT_SP {if (options.protect_sp_update) { \
+ symbol *lbl = newiTempLabel(NULL); \
+ emitcode ("setb","F1"); \
+ emitcode ("jbc","EA,!tlabel",lbl->key+100); \
+ emitcode ("clr","F1"); \
+ emitcode ("","!tlabeldef",lbl->key+100); \
+ }}
+#define UNPROTECT_SP { if (options.protect_sp_update) { \
+ symbol *lbl = newiTempLabel(NULL); \
+ emitcode ("jnb","F1,!tlabel",lbl->key+100); \
+ emitcode ("setb","EA"); \
+ emitcode ("","!tlabeldef",lbl->key+100); \
+ }}
+
/*-----------------------------------------------------------------*/
/* emitcode - writes the code into a file : for now it is simple */
static void
emitcode (char *inst, char *fmt,...)
{
- va_list ap;
- char lb[INITIAL_INLINEASM];
- char *lbp = lb;
-
- va_start (ap, fmt);
-
- if (inst && *inst)
+ va_list ap;
+ char lb[INITIAL_INLINEASM];
+ char *lbp = lb;
+
+ va_start (ap, fmt);
+
+ if (inst && *inst)
{
- if (fmt && *fmt)
- sprintf (lb, "%s\t", inst);
- else
- sprintf (lb, "%s", inst);
- vsprintf (lb + (strlen (lb)), fmt, ap);
+ if (fmt && *fmt)
+ {
+ SNPRINTF (lb, sizeof(lb), "%s\t", inst);
+ }
+ else
+ {
+ SNPRINTF (lb, sizeof(lb), "%s", inst);
+ }
+
+ tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb),
+ fmt, ap);
}
- else
- vsprintf (lb, fmt, ap);
+ else
+ {
+ tvsprintf (lb, sizeof(lb), fmt, ap);
+ }
+
- while (isspace (*lbp))
- lbp++;
+ while (isspace (*lbp))
+ {
+ lbp++;
+ }
- if (lbp && *lbp)
- lineCurr = (lineCurr ?
- connectLine (lineCurr, newLineNode (lb)) :
- (lineHead = newLineNode (lb)));
- lineCurr->isInline = _G.inLine;
- lineCurr->isDebug = _G.debugLine;
- va_end (ap);
+ if (lbp && *lbp)
+ {
+ lineCurr = (lineCurr ?
+ connectLine (lineCurr, newLineNode (lb)) :
+ (lineHead = newLineNode (lb)));
+ }
+
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+ va_end (ap);
}
/*-----------------------------------------------------------------*/
if (!n)
{
- emitcode ("mov", "dps, #0x00");
+ emitcode ("mov", "dps,#0");
}
else
{
TR_DPTR("#1");
- emitcode ("mov", "dps, #0x01");
+ emitcode ("mov", "dps,#1");
}
}
if (_G.accInUse)
emitcode ("push", "acc");
+ if (_G.bInUse)
+ emitcode ("push", "b");
+
emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x",
+ emitcode ("add", "a,#!constbyte",
((sym->stack < 0) ?
((char) (sym->stack - _G.nRegsSaved)) :
((char) sym->stack)) & 0xff);
emitcode ("mov", "%s,a",
aop->aopu.aop_ptr->name);
+ if (_G.bInUse)
+ emitcode ("pop", "b");
+
if (_G.accInUse)
emitcode ("pop", "acc");
}
if (sym->onStack && options.stack10bit)
{
+ short stack_val = -((sym->stack < 0) ?
+ ((short) (sym->stack - _G.nRegsSaved)) :
+ ((short) sym->stack)) ;
+ if (useDP2 && _G.dptr1InUse) {
+ emitcode ("push","dpl1");
+ emitcode ("push","dph1");
+ emitcode ("push","dpx1");
+ } else if (_G.dptrInUse ) {
+ emitcode ("push","dpl");
+ emitcode ("push","dph");
+ emitcode ("push","dpx");
+ }
/* It's on the 10 bit stack, which is located in
* far data space.
- */
-
- if (_G.accInUse)
- emitcode ("push", "acc");
-
- emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x",
- ((sym->stack < 0) ?
- ((char) (sym->stack - _G.nRegsSaved)) :
- ((char) sym->stack)) & 0xff);
-
- if (useDP2)
- {
- if (options.model == MODEL_FLAT24)
- emitcode ("mov", "dpx1,#0x40");
- TR_DPTR("#2");
- emitcode ("mov", "dph1,#0x00");
- emitcode ("mov", "dpl1, a");
- }
- else
- {
- if (options.model == MODEL_FLAT24)
- emitcode ("mov", "dpx,#0x40");
- emitcode ("mov", "dph,#0x00");
- emitcode ("mov", "dpl, a");
+ */
+ if (stack_val < 0 && stack_val > -5) { /* between -5 & -1 */
+ if (useDP2) {
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
+ TR_DPTR("#2");
+ emitcode ("mov", "dph1,_bpx+1");
+ emitcode ("mov", "dpl1,_bpx");
+ emitcode ("mov","dps,#1");
+ } else {
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
+ emitcode ("mov", "dph,_bpx+1");
+ emitcode ("mov", "dpl,_bpx");
+ }
+ stack_val = -stack_val;
+ while (stack_val--) {
+ emitcode ("inc","dptr");
+ }
+ if (useDP2) {
+ emitcode("mov","dps,#0");
+ }
+ } else {
+ if (_G.accInUse)
+ emitcode ("push", "acc");
+
+ if (_G.bInUse)
+ emitcode ("push", "b");
+
+ emitcode ("mov", "a,_bpx");
+ emitcode ("clr","c");
+ emitcode ("subb", "a,#!constbyte", stack_val & 0xff);
+ emitcode ("mov","b,a");
+ emitcode ("mov","a,_bpx+1");
+ emitcode ("subb","a,#!constbyte",(stack_val >> 8) & 0xff);
+ if (useDP2) {
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
+ TR_DPTR("#2");
+ emitcode ("mov", "dph1,a");
+ emitcode ("mov", "dpl1,b");
+ } else {
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
+ emitcode ("mov", "dph,a");
+ emitcode ("mov", "dpl,b");
+ }
+
+ if (_G.bInUse)
+ emitcode ("pop", "b");
+
+ if (_G.accInUse)
+ emitcode ("pop", "acc");
}
-
- if (_G.accInUse)
- emitcode ("pop", "acc");
-
- sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
- aop->size = getSize (sym->type);
- return aop;
+ sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
+ aop->size = getSize (sym->type);
+ return aop;
}
/* if in bit space */
if (IS_FUNC (sym->type))
{
sym->aop = aop = newAsmop (AOP_IMMD);
- aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname);
+ aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);
aop->size = FPTRSIZE;
return aop;
}
-
+
/* only remaining is far space */
/* in which case DPTR gets the address */
sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
{
iCode *ic = sym->rematiCode;
asmop *aop = newAsmop (AOP_IMMD);
- int ptr_type ;
+ int ptr_type =0;
int val = 0;
for (;;)
aop->aopu.aop_immd.from_cast_remat = 1;
ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
ptr_type = DCL_TYPE(from_type);
+ if (ptr_type == IPOINTER) {
+ // bug #481053
+ ptr_type = POINTER;
+ }
continue ;
} else break;
}
if (val)
- sprintf (buffer, "(%s %c 0x%04x)",
- OP_SYMBOL (IC_LEFT (ic))->rname,
- val >= 0 ? '+' : '-',
- abs (val) & 0xffff);
- else
- strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s %c 0x%04x)",
+ OP_SYMBOL (IC_LEFT (ic))->rname,
+ val >= 0 ? '+' : '-',
+ abs (val) & 0xffff);
+ }
+ else
+ {
+ if (IS_ASSIGN_ICODE(ic) && isOperandLiteral(IC_RIGHT(ic)))
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "0x%x",(int) operandLitValue (IC_RIGHT (ic)));
+ }
+ else
+ {
+ strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
+ }
+ }
- aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+ aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer);
/* set immd2 field if required */
- if (aop->aopu.aop_immd.from_cast_remat) {
- sprintf(buffer,"#0x%02x",ptr_type);
- aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
+ if (aop->aopu.aop_immd.from_cast_remat)
+ {
+ tsprintf(buffer, sizeof(buffer), "#!constbyte",ptr_type);
+ aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer);
}
return aop;
}
+/*-----------------------------------------------------------------*/
+/* aopHasRegs - returns true if aop has regs between from-to */
+/*-----------------------------------------------------------------*/
+static int aopHasRegs(asmop *aop, int from, int to)
+{
+ int size =0;
+
+ if (aop->type != AOP_REG) return 0; /* if not assigned to regs */
+
+ for (; size < aop->size ; size++) {
+ int reg;
+ for (reg = from ; reg <= to ; reg++)
+ if (aop->aopu.aop_reg[size] == ds390_regWithIdx(reg)) return 1;
+ }
+ return 0;
+}
+
/*-----------------------------------------------------------------*/
/* regsInCommon - two operands have some registers in common */
/*-----------------------------------------------------------------*/
/* a AOP_STR uses DPTR, but DPTR is already in use;
* we're just hosed.
*/
- fprintf (stderr, "*** Internal error: AOP_STR with DPTR in use!\n");
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"AOP_STR with DPTR in use!");
}
aop = op->aop = sym->aop = newAsmop (AOP_STR);
aop->aopu.aop_str[i] = fReturn[i];
return;
}
-
+
+ if (sym->dptr) { /* has been allocated to a DPTRn */
+ aop = op->aop = sym->aop = newAsmop (AOP_DPTRn);
+ aop->size = getSize (sym->type);
+ aop->aopu.dptr = sym->dptr;
+ return ;
+ }
/* else spill location */
+ if (sym->usl.spillLoc && getSize(sym->type) != getSize(sym->usl.spillLoc->type)) {
+ /* force a new aop if sizes differ */
+ sym->usl.spillLoc->aop = NULL;
+ }
sym->aop = op->aop = aop =
aopForSym (ic, sym->usl.spillLoc, result, useDP2);
aop->size = getSize (sym->type);
if (stk)
{
emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x", ((char) stk) & 0xff);
+ emitcode ("add", "a,#!constbyte", ((char) stk) & 0xff);
emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
}
else
_G.r1Pushed--;
}
}
+ case AOP_DPTR2:
+ if (_G.dptr1InUse) {
+ emitcode ("pop","dpx1");
+ emitcode ("pop","dph1");
+ emitcode ("pop","dpl1");
+ }
+ break;
+ case AOP_DPTR:
+ if (_G.dptrInUse) {
+ emitcode ("pop","dpx");
+ emitcode ("pop","dph");
+ emitcode ("pop","dpl");
+ }
+ break;
}
-
dealloc:
/* all other cases just dealloc */
if (op)
bool dname,
bool canClobberACC)
{
- char *s = buffer;
- char *rs;
-
/* offset is greater than
size then zero */
if (offset > (aop->size - 1) &&
emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
return (dname ? "acc" : "a");
}
- sprintf (s, "@%s", aop->aopu.aop_ptr->name);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name);
+ return Safe_strdup(buffer);
+
+ case AOP_DPTRn:
+ assert(offset <= 3);
+ return dptrn[aop->aopu.dptr][offset];
case AOP_DPTR:
case AOP_DPTR2:
return (dname ? "acc" : "a");
case AOP_IMMD:
- if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) {
- sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2);
- } else if (bit16)
- sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1);
- else if (offset)
- sprintf (s, "#(%s >> %d)",
- aop->aopu.aop_immd.aop_immd1,
- offset * 8);
+ if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1)))
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "%s",aop->aopu.aop_immd.aop_immd2);
+ }
+ else if (bit16)
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "#%s", aop->aopu.aop_immd.aop_immd1);
+ }
+ else if (offset)
+ {
+ switch (offset) {
+ case 1:
+ tsprintf(buffer, sizeof(buffer),
+ "#!his",aop->aopu.aop_immd.aop_immd1);
+ break;
+ case 2:
+ tsprintf(buffer, sizeof(buffer),
+ "#!hihis",aop->aopu.aop_immd.aop_immd1);
+ break;
+ case 3:
+ tsprintf(buffer, sizeof(buffer),
+ "#!hihihis",aop->aopu.aop_immd.aop_immd1);
+ break;
+ default: /* should not need this (just in case) */
+ SNPRINTF (buffer, sizeof(buffer),
+ "#(%s >> %d)",
+ aop->aopu.aop_immd.aop_immd1,
+ offset * 8);
+ }
+ }
else
- sprintf (s, "#%s",
- aop->aopu.aop_immd.aop_immd1);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#%s", aop->aopu.aop_immd.aop_immd1);
+ }
+ return Safe_strdup(buffer);
case AOP_DIR:
if (offset)
- sprintf (s, "(%s + %d)",
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s + %d)",
aop->aopu.aop_dir,
offset);
+ }
else
- sprintf (s, "%s", aop->aopu.aop_dir);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "%s", aop->aopu.aop_dir);
+ }
+
+ return Safe_strdup(buffer);
case AOP_REG:
if (dname)
static void
aopPut (asmop * aop, char *s, int offset)
{
- char *d = buffer;
-
if (aop->size && offset > (aop->size - 1))
{
werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
switch (aop->type)
{
case AOP_DIR:
- if (offset)
- sprintf (d, "(%s + %d)",
- aop->aopu.aop_dir, offset);
- else
- sprintf (d, "%s", aop->aopu.aop_dir);
-
- if (strcmp (d, s))
- emitcode ("mov", "%s,%s", d, s);
+ if (offset)
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s + %d)",
+ aop->aopu.aop_dir, offset);
+ }
+ else
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "%s", aop->aopu.aop_dir);
+ }
+
+ if (strcmp (buffer, s))
+ {
+ emitcode ("mov", "%s,%s", buffer, s);
+ }
break;
case AOP_REG:
strcmp (s, "r5") == 0 ||
strcmp (s, "r6") == 0 ||
strcmp (s, "r7") == 0)
- emitcode ("mov", "%s,%s",
- aop->aopu.aop_reg[offset]->dname, s);
- else
- emitcode ("mov", "%s,%s",
- aop->aopu.aop_reg[offset]->name, s);
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_reg[offset]->dname, s);
+ }
+ else
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_reg[offset]->name, s);
+ }
}
break;
+ case AOP_DPTRn:
+ emitcode ("mov","%s,%s",dptrn[aop->aopu.dptr][offset],s);
+ break;
+
case AOP_DPTR:
case AOP_DPTR2:
strcmp (s, "r6") == 0 ||
strcmp (s, "r7") == 0)
{
- char buffer[10];
- sprintf (buffer, "a%s", s);
+ char buff[10];
+ SNPRINTF(buff, sizeof(buff),
+ "a%s", s);
emitcode ("mov", "@%s,%s",
- aop->aopu.aop_ptr->name, buffer);
+ aop->aopu.aop_ptr->name, buff);
+ }
+ else
+ {
+ emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
}
- else
- emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
-
break;
case AOP_STK:
if (strcmp (s, "a") == 0)
emitcode ("push", "acc");
else
- emitcode ("push", "%s", s);
+ if (*s=='@') {
+ MOVA(s);
+ emitcode ("push", "acc");
+ } else {
+ emitcode ("push", s);
+ }
break;
MOVA (s);
}
{
- symbol *lbl = newiTempLabel (NULL);
- emitcode ("clr", "c");
- emitcode ("jz", "%05d$", lbl->key + 100);
- emitcode ("cpl", "c");
- emitcode ("", "%05d$:", lbl->key + 100);
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#!constbyte",0xff);
emitcode ("mov", "%s,c", aop->aopu.aop_dir);
}
}
#define AOP_INPREG(x) (x && (x->type == AOP_REG && \
(x->aopu.aop_reg[0] == ds390_regWithIdx(R0_IDX) || \
x->aopu.aop_reg[0] == ds390_regWithIdx(R1_IDX) )))
+#define AOP_INDPTRn(x) (AOP_TYPE(x) == AOP_DPTRn)
+#define AOP_USESDPTR(x) ((AOP_TYPE(x) == AOP_DPTR) || (AOP_TYPE(x) == AOP_STR))
+#define AOP_USESDPTR2(x) ((AOP_TYPE(x) == AOP_DPTR2) || (AOP_TYPE(x) == AOP_DPTRn))
+
+// The following two macros can be used even if the aop has not yet been aopOp'd.
+#define AOP_IS_STR(x) (IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
+#define AOP_IS_DPTRn(x) (IS_SYMOP(x) && OP_SYMBOL(x)->dptr)
/* Workaround for DS80C390 bug: div ab may return bogus results
* if A is accessed in instruction immediately before the div.
tlbl = newiTempLabel (NULL);
aopPut (res->aop, one, 1);
- emitcode ("jz", "%05d$", (tlbl->key + 100));
+ emitcode ("jz", "!tlabel", (tlbl->key + 100));
aopPut (res->aop, zero, 1);
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitcode ("", "!tlabeldef", (tlbl->key + 100));
size = res->aop->size - 2;
offset = 2;
*/
if (opIsGptr (oper))
{
- D (emitcode (";", "toBoolean: generic ptr special case.");
- );
+ D (emitcode (";", "toBoolean: generic ptr special case."););
size--;
}
toBoolean (IC_LEFT (ic));
tlbl = newiTempLabel (NULL);
- emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("cjne", "a,#1,!tlabel", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
outBitC (IC_RESULT (ic));
release:
{
int offset = 0;
int size;
+ symbol *tlbl;
D (emitcode (";", "genCpl ");
);
aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
- /* if both are in bit space then
- a special case */
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY &&
- AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
- {
-
+ /* special case if in bit space */
+ if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) {
+ if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) {
emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
emitcode ("cpl", "c");
emitcode ("mov", "%s,c", IC_RESULT (ic)->aop->aopu.aop_dir);
goto release;
}
+ tlbl=newiTempLabel(NULL);
+ emitcode ("cjne", "%s,#0x01,%05d$",
+ aopGet(AOP(IC_LEFT(ic)), 0, FALSE,FALSE,TRUE), tlbl->key+100);
+ emitcode ("", "%05d$:", tlbl->key+100);
+ outBitC (IC_RESULT(ic));
+ goto release;
+ }
size = AOP_SIZE (IC_RESULT (ic));
_startLazyDPSEvaluation ();
genUminusFloat (operand * op, operand * result)
{
int size, offset = 0;
- char *l;
- /* for this we just need to flip the
- first it then copy the rest in place */
- D (emitcode (";", "genUminusFloat");
- );
-
+
+ D(emitcode (";", "genUminusFloat"););
+
+ /* for this we just copy and then flip the bit */
+
_startLazyDPSEvaluation ();
size = AOP_SIZE (op) - 1;
- l = aopGet (AOP (op), 3, FALSE, FALSE, TRUE);
- MOVA (l);
-
- emitcode ("cpl", "acc.7");
- aopPut (AOP (result), "a", 3);
while (size--)
- {
+ {
aopPut (AOP (result),
aopGet (AOP (op), offset, FALSE, FALSE, FALSE),
offset);
offset++;
}
+
+ MOVA(aopGet (AOP (op), offset, FALSE, FALSE, TRUE));
+
+ emitcode ("cpl", "acc.7");
+ aopPut (AOP (result), "a", offset);
_endLazyDPSEvaluation ();
}
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
+/*-----------------------------------------------------------------*/
+/* savermask - saves registers in the mask */
+/*-----------------------------------------------------------------*/
+static void savermask(bitVect *rs_mask)
+{
+ int i;
+ if (options.useXstack) {
+ if (bitVectBitValue (rs_mask, R0_IDX))
+ emitcode ("mov", "b,r0");
+ emitcode ("mov", "r0,%s", spname);
+ for (i = 0; i < ds390_nRegs; i++) {
+ if (bitVectBitValue (rs_mask, i)) {
+ if (i == R0_IDX)
+ emitcode ("mov", "a,b");
+ else
+ emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name);
+ emitcode ("movx", "@r0,a");
+ emitcode ("inc", "r0");
+ }
+ }
+ emitcode ("mov", "%s,r0", spname);
+ if (bitVectBitValue (rs_mask, R0_IDX))
+ emitcode ("mov", "r0,b");
+ } else {
+ for (i = 0; i < ds390_nRegs; i++) {
+ if (bitVectBitValue (rs_mask, i))
+ emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
+ }
+ }
+}
+
/*-----------------------------------------------------------------*/
/* saveRegisters - will look for a call and save the registers */
/*-----------------------------------------------------------------*/
static void
saveRegisters (iCode * lic)
{
- int i;
iCode *ic;
bitVect *rsave;
- sym_link *detype;
/* look for call */
for (ic = lic; ic; ic = ic->next)
/* if the registers have been saved already then
do nothing */
- if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type) ||
- IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic))))
- return;
-
- /* find the registers in use at this time
- and push them away to safety */
- rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
- ic->rUsed);
-
+ if (ic->regsSaved || IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic)))) return ;
+
+ /* special case if DPTR alive across a function call then must save it
+ even though callee saves */
+ if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
+ int i =0;
+ rsave = newBitVect(ic->rMask->size);
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
+ }
+ rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic)));
+ } else {
+ /* safe the registers in use at this time but skip the
+ ones for the result */
+ rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic)));
+ }
ic->regsSaved = 1;
- if (options.useXstack)
- {
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "b,r0");
- emitcode ("mov", "r0,%s", spname);
- for (i = 0; i < ds390_nRegs; i++)
- {
- if (bitVectBitValue (rsave, i))
- {
- if (i == R0_IDX)
- emitcode ("mov", "a,b");
- else
- emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name);
- emitcode ("movx", "@r0,a");
- emitcode ("inc", "r0");
- }
+ savermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* usavermask - restore registers with mask */
+/*-----------------------------------------------------------------*/
+static void unsavermask(bitVect *rs_mask)
+{
+ int i;
+ if (options.useXstack) {
+ emitcode ("mov", "r0,%s", spname);
+ for (i = ds390_nRegs; i >= 0; i--) {
+ if (bitVectBitValue (rs_mask, i)) {
+ emitcode ("dec", "r0");
+ emitcode ("movx", "a,@r0");
+ if (i == R0_IDX)
+ emitcode ("mov", "b,a");
+ else
+ emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name);
+ }
+ }
+ emitcode ("mov", "%s,r0", spname);
+ if (bitVectBitValue (rs_mask, R0_IDX))
+ emitcode ("mov", "r0,b");
+ } else {
+ for (i = ds390_nRegs; i >= 0; i--) {
+ if (bitVectBitValue (rs_mask, i))
+ emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
}
- emitcode ("mov", "%s,r0", spname);
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "r0,b");
}
- else
- for (i = 0; i < ds390_nRegs; i++)
- {
- if (bitVectBitValue (rsave, i))
- emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
- }
-
- detype = getSpec (operandType (IC_LEFT (ic)));
}
/*-----------------------------------------------------------------*/
static void
unsaveRegisters (iCode * ic)
{
- int i;
bitVect *rsave;
- /* find the registers in use at this time
- and push them away to safety */
- rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
- ic->rUsed);
-
- if (options.useXstack)
- {
- emitcode ("mov", "r0,%s", spname);
- for (i = ds390_nRegs; i >= 0; i--)
- {
- if (bitVectBitValue (rsave, i))
- {
- emitcode ("dec", "r0");
- emitcode ("movx", "a,@r0");
- if (i == R0_IDX)
- emitcode ("mov", "b,a");
- else
- emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name);
- }
- }
- emitcode ("mov", "%s,r0", spname);
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "r0,b");
- }
- else
- for (i = ds390_nRegs; i >= 0; i--)
- {
- if (bitVectBitValue (rsave, i))
- emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
+ if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
+ int i =0;
+ rsave = newBitVect(ic->rMask->size);
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
}
-
+ rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic)));
+ } else {
+ /* restore the registers in use at this time but skip the
+ ones for the result */
+ rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic)));
+ }
+ unsavermask(rsave);
}
{
/* and the item is spilt then do nothing */
- if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
+ if (OP_SYMBOL (IC_LEFT (ic))->isspilt || OP_SYMBOL(IC_LEFT(ic))->dptr)
return;
aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
/* if the temp was not pushed then */
- if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
+ if (OP_SYMBOL (IC_LEFT (ic))->isspilt || OP_SYMBOL (IC_LEFT (ic))->dptr)
return;
aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
}
}
- for (i = (ds390_nRegs - 1); i >= 0; i--)
+ for (i = 7; i >= 0; i--) /* only R7-R0 needs to be popped */
{
if (options.useXstack)
{
emitcode ("mov", "%s,_spx", r->name);
}
- for (i = 0; i < ds390_nRegs; i++)
+ for (i = 0; i < 8 ; i++) /* only R0-R7 needs saving */
{
if (options.useXstack)
{
emitcode ("push", "psw");
}
- emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
+ emitcode ("mov", "psw,#!constbyte", (bank << 3) & 0x00ff);
}
if (aop)
}
}
+/*-----------------------------------------------------------------*/
+/* genSend - gen code for SEND */
+/*-----------------------------------------------------------------*/
+static void genSend(set *sendSet)
+{
+ iCode *sic;
+ int sendCount = 0 ;
+ static int rb1_count = 0;
+
+ for (sic = setFirstItem (sendSet); sic;
+ sic = setNextItem (sendSet)) {
+ int size, offset = 0;
+
+ size=getSize(operandType(IC_LEFT(sic)));
+ D (emitcode (";", "genSend argreg = %d, size = %d ",sic->argreg,size));
+ if (sendCount == 0) { /* first parameter */
+ // we know that dpl(hxb) is the result, so
+ rb1_count = 0 ;
+ _startLazyDPSEvaluation ();
+ if (size>1) {
+ aopOp (IC_LEFT (sic), sic, FALSE,
+ (AOP_IS_STR(IC_LEFT(sic)) ? FALSE : TRUE));
+ } else {
+ aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
+ }
+ while (size--) {
+ char *l = aopGet (AOP (IC_LEFT (sic)), offset,
+ FALSE, FALSE, TRUE);
+ if (strcmp (l, fReturn[offset])) {
+ emitcode ("mov", "%s,%s",
+ fReturn[offset],
+ l);
+ }
+ offset++;
+ }
+ _endLazyDPSEvaluation ();
+ freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ rb1_count =0;
+ } else { /* if more parameter in registers */
+ aopOp (IC_LEFT (sic), sic, FALSE, TRUE);
+ while (size--) {
+ emitcode ("mov","b1_%d,%s",rb1_count++,aopGet (AOP (IC_LEFT (sic)), offset++,
+ FALSE, FALSE, TRUE));
+ }
+ freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ }
+ sendCount++;
+ }
+}
+
/*-----------------------------------------------------------------*/
/* genCall - generates a call statement */
/*-----------------------------------------------------------------*/
the same register bank then we need to save the
destination registers on the stack */
dtype = operandType (IC_LEFT (ic));
- if (dtype && !IFFUNC_ISNAKED(dtype) &&
+ if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
(FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
IFFUNC_ISISR (currFunc->type))
{
*/
if (_G.sendSet)
{
- iCode *sic;
-
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet))
- {
- int size, offset = 0;
-
- aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
- size = AOP_SIZE (IC_LEFT (sic));
-
- _startLazyDPSEvaluation ();
- while (size--)
- {
- char *l = aopGet (AOP(IC_LEFT(sic)), offset,
- FALSE, FALSE, TRUE);
- if ((AOP_TYPE(IC_LEFT(sic)) == AOP_DPTR) && size)
- {
- emitcode("mov", "%s,%s", regs390[offset].name, l);
- }
- else if (strcmp (l, fReturn[offset]))
- {
- emitcode ("mov", "%s,%s",
- fReturn[offset],
- l);
- }
- offset++;
- }
- _endLazyDPSEvaluation ();
- if (AOP_TYPE(IC_LEFT(sic)) == AOP_DPTR)
- {
- size = AOP_SIZE (IC_LEFT (sic));
- if (size)
- {
- size--;
- }
- while (size)
- {
- size--;
- emitcode("mov", "%s,%s",
- fReturn[size], regs390[size].name);
- }
- }
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
+ genSend(reverseSet(_G.sendSet));
+ } else {
+ genSend(_G.sendSet);
}
_G.sendSet = NULL;
}
if (swapBanks)
{
- emitcode ("mov", "psw,#0x%02x",
+ emitcode ("mov", "psw,#!constbyte",
((FUNC_REGBANK(dtype)) << 3) & 0xff);
}
if (swapBanks)
{
- emitcode ("mov", "psw,#0x%02x",
+ emitcode ("mov", "psw,#!constbyte",
((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
}
/* if we need assign a result value */
if ((IS_ITEMP (IC_RESULT (ic)) &&
(OP_SYMBOL (IC_RESULT (ic))->nRegs ||
+ OP_SYMBOL (IC_RESULT (ic))->accuse ||
OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
IS_TRUE_SYMOP (IC_RESULT (ic)))
{
/* adjust the stack for parameters if
required */
- if (ic->parmBytes)
- {
+ if (ic->parmBytes) {
int i;
- if (ic->parmBytes > 3)
- {
- emitcode ("mov", "a,%s", spname);
- emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
- emitcode ("mov", "%s,a", spname);
- }
- else
- for (i = 0; i < ic->parmBytes; i++)
- emitcode ("dec", "%s", spname);
- }
+ if (options.stack10bit) {
+ if (ic->parmBytes <= 10) {
+ emitcode(";","stack adjustment for parms");
+ for (i=0; i < ic->parmBytes ; i++) {
+ emitcode("pop","acc");
+ }
+ } else {
+ PROTECT_SP;
+ emitcode ("clr","c");
+ emitcode ("mov","a,sp");
+ emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
+ emitcode ("mov","sp,a");
+ emitcode ("mov","a,esp");
+ emitcode ("anl","a,#3");
+ emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
+ emitcode ("mov","esp,a");
+ UNPROTECT_SP;
+ }
+ } else {
+ if (ic->parmBytes > 3) {
+ emitcode ("mov", "a,%s", spname);
+ emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
+ emitcode ("mov", "%s,a", spname);
+ } else
+ for (i = 0; i < ic->parmBytes; i++)
+ emitcode ("dec", "%s", spname);
+ }
+ }
/* if we hade saved some registers then unsave them */
- if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+ if (ic->regsSaved)
unsaveRegisters (ic);
/* if register bank was saved then pop them */
{
sym_link *dtype;
symbol *rlbl = newiTempLabel (NULL);
+ bool restoreBank=FALSE;
D (emitcode (";", "genPcall ");
);
the same register bank then we need to save the
destination registers on the stack */
dtype = operandType (IC_LEFT (ic));
- if (dtype &&
+ if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
IFFUNC_ISISR (currFunc->type) &&
- (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)))
+ (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype))) {
saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
-
+ restoreBank=TRUE;
+ }
/* push the return address on to the stack */
- emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
+ emitcode ("mov", "a,#!tlabel", (rlbl->key + 100));
emitcode ("push", "acc");
- emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
+ emitcode ("mov", "a,#!hil", (rlbl->key + 100));
emitcode ("push", "acc");
if (options.model == MODEL_FLAT24)
{
- emitcode ("mov", "a,#(%05d$ >> 16)", (rlbl->key + 100));
+ emitcode ("mov", "a,#!hihil", (rlbl->key + 100));
emitcode ("push", "acc");
}
/* if send set is not empty the assign */
if (_G.sendSet)
{
- iCode *sic;
-
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet))
- {
- int size, offset = 0;
-
- aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
- size = AOP_SIZE (IC_LEFT (sic));
- _startLazyDPSEvaluation ();
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (sic)), offset,
- FALSE, FALSE, TRUE);
- if (strcmp (l, fReturn[offset]))
- {
- emitcode ("mov", "%s,%s",
- fReturn[offset],
- l);
- }
- offset++;
- }
- _endLazyDPSEvaluation ();
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
- }
- _G.sendSet = NULL;
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
}
emitcode ("ret", "");
- emitcode ("", "%05d$:", (rlbl->key + 100));
+ emitcode ("", "!tlabeldef", (rlbl->key + 100));
/* if we need assign a result value */
if (ic->parmBytes)
{
int i;
- if (ic->parmBytes > 3)
- {
- emitcode ("mov", "a,%s", spname);
- emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
- emitcode ("mov", "%s,a", spname);
- }
- else
- for (i = 0; i < ic->parmBytes; i++)
- emitcode ("dec", "%s", spname);
-
+ if (options.stack10bit) {
+ if (ic->parmBytes <= 10) {
+ emitcode(";","stack adjustment for parms");
+ for (i=0; i < ic->parmBytes ; i++) {
+ emitcode("pop","acc");
+ }
+ } else {
+ PROTECT_SP;
+ emitcode ("clr","c");
+ emitcode ("mov","a,sp");
+ emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
+ emitcode ("mov","sp,a");
+ emitcode ("mov","a,esp");
+ emitcode ("anl","a,#3");
+ emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
+ emitcode ("mov","esp,a");
+ UNPROTECT_SP;
+ }
+ } else {
+ if (ic->parmBytes > 3) {
+ emitcode ("mov", "a,%s", spname);
+ emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
+ emitcode ("mov", "%s,a", spname);
+ }
+ else
+ for (i = 0; i < ic->parmBytes; i++)
+ emitcode ("dec", "%s", spname);
+
+ }
}
-
/* if register bank was saved then unsave them */
- if (dtype &&
- (FUNC_REGBANK (currFunc->type) !=
- FUNC_REGBANK (dtype)))
+ if (restoreBank)
unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
-
+
/* if we hade saved some registers then
unsave them */
if (ic->regsSaved)
emitcode(";", "naked function: no prologue.");
return;
}
-
+
+ if (options.stack_probe)
+ emitcode ("lcall","__stack_probe");
/* if critical function then turn interrupts off */
if (IFFUNC_ISCRITICAL (ftype))
emitcode ("clr", "ea");
rbank = FUNC_REGBANK (ftype);
for (i = 0; i < ds390_nRegs; i++)
{
- if (strcmp (regs390[i].base, "0") == 0)
- emitcode ("", "%s = 0x%02x",
- regs390[i].dname,
- 8 * rbank + regs390[i].offset);
- else
- emitcode ("", "%s = %s + 0x%02x",
- regs390[i].dname,
- regs390[i].base,
- 8 * rbank + regs390[i].offset);
+ if (regs390[i].print) {
+ if (strcmp (regs390[i].base, "0") == 0)
+ emitcode ("", "%s !equ !constbyte",
+ regs390[i].dname,
+ 8 * rbank + regs390[i].offset);
+ else
+ emitcode ("", "%s !equ %s + !constbyte",
+ regs390[i].dname,
+ regs390[i].base,
+ 8 * rbank + regs390[i].offset);
+ }
}
}
/* if this is an interrupt service routine then
save acc, b, dpl, dph */
if (IFFUNC_ISISR (sym->type))
- {
-
+ { /* is ISR */
if (!inExcludeList ("acc"))
emitcode ("push", "acc");
if (!inExcludeList ("b"))
emitcode ("push", "dpx");
/* Make sure we're using standard DPTR */
emitcode ("push", "dps");
- emitcode ("mov", "dps, #0x00");
+ emitcode ("mov", "dps,#0");
if (options.stack10bit)
{
/* This ISR could conceivably use DPTR2. Better save it. */
registers :-) */
if (!FUNC_REGBANK (sym->type))
{
+ int i;
/* if this function does not call any other
function then we can be economical and
save only those registers that are used */
if (!IFFUNC_HASFCALL(sym->type))
{
- int i;
/* if any registers used */
if (sym->regsUsed)
determines register usage so we will have to push the
entire bank */
saveRBank (0, ic, FALSE);
+ if (options.parms_in_bank1) {
+ for (i=0; i < 8 ; i++ ) {
+ emitcode ("push","%s",rb1regs[i]);
+ }
+ }
}
}
else
* the caller's R0 isn't trashed.
*/
emitcode ("push", "psw");
- emitcode ("mov", "psw,#0x%02x",
+ emitcode ("mov", "psw,#!constbyte",
(FUNC_REGBANK (sym->type) << 3) & 0x00ff);
switchedPSW = TRUE;
}
&& !switchedPSW)
{
emitcode ("push", "psw");
- emitcode ("mov", "psw,#0x%02x", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
- }
-
- if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
- {
-
- if (options.useXstack)
- {
- emitcode ("mov", "r0,%s", spname);
- emitcode ("mov", "a,_bp");
- emitcode ("movx", "@r0,a");
- emitcode ("inc", "%s", spname);
- }
- else
- {
- /* set up the stack */
- emitcode ("push", "_bp"); /* save the callers stack */
- }
- emitcode ("mov", "_bp,%s", spname);
- }
+ emitcode ("mov", "psw,#!constbyte", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
+ }
+
+ if ( (IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+ (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+ if (options.stack10bit) {
+ emitcode ("push","_bpx");
+ emitcode ("push","_bpx+1");
+ emitcode ("mov","_bpx,%s",spname);
+ emitcode ("mov","_bpx+1,esp");
+ emitcode ("anl","_bpx+1,#3");
+ } else {
+ if (options.useXstack) {
+ emitcode ("mov", "r0,%s", spname);
+ emitcode ("mov", "a,_bp");
+ emitcode ("movx", "@r0,a");
+ emitcode ("inc", "%s", spname);
+ } else {
+ /* set up the stack */
+ emitcode ("push", "_bp"); /* save the callers stack */
+ }
+ emitcode ("mov", "_bp,%s", spname);
+ }
+ }
/* adjust the stack for the function */
- if (sym->stack)
- {
-
+ if (sym->stack) {
int i = sym->stack;
- if (i > 256)
- werror (W_STACK_OVERFLOW, sym->name);
-
- if (i > 3 && sym->recvSize < 4)
- {
-
- emitcode ("mov", "a,sp");
- emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
- emitcode ("mov", "sp,a");
-
- }
- else
- while (i--)
- emitcode ("inc", "sp");
- }
+ if (options.stack10bit) {
+ if ( i > 1024) werror (W_STACK_OVERFLOW, sym->name);
+ assert (sym->recvSize <= 4);
+ if (sym->stack <= 8) {
+ while (i--) emitcode ("push","acc");
+ } else {
+ PROTECT_SP;
+ emitcode ("mov","a,sp");
+ emitcode ("add","a,#!constbyte", ((short) sym->stack & 0xff));
+ emitcode ("mov","sp,a");
+ emitcode ("mov","a,esp");
+ emitcode ("anl","a,#3");
+ emitcode ("addc","a,#!constbyte", (((short) sym->stack) >> 8) & 0xff);
+ emitcode ("mov","esp,a");
+ UNPROTECT_SP;
+ }
+ } else {
+ if (i > 256)
+ werror (W_STACK_OVERFLOW, sym->name);
+
+ if (i > 3 && sym->recvSize < 4) {
+
+ emitcode ("mov", "a,sp");
+ emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
+ emitcode ("mov", "sp,a");
+
+ } else
+ while (i--)
+ emitcode ("inc", "sp");
+ }
+ }
if (sym->xstack)
{
emitcode ("mov", "a,_spx");
- emitcode ("add", "a,#0x%02x", ((char) sym->xstack & 0xff));
+ emitcode ("add", "a,#!constbyte", ((char) sym->xstack & 0xff));
emitcode ("mov", "_spx,a");
}
return;
}
- if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
- {
- emitcode ("mov", "%s,_bp", spname);
- }
+ if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+ (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+
+ if (options.stack10bit) {
+ PROTECT_SP;
+ emitcode ("mov", "sp,_bpx", spname);
+ emitcode ("mov", "esp,_bpx+1", spname);
+ UNPROTECT_SP;
+ } else {
+ emitcode ("mov", "%s,_bp", spname);
+ }
+ }
/* if use external stack but some variables were
added to the local stack then decrement the
local stack */
- if (options.useXstack && sym->stack)
- {
+ if (options.useXstack && sym->stack) {
emitcode ("mov", "a,sp");
- emitcode ("add", "a,#0x%02x", ((char) -sym->stack) & 0xff);
+ emitcode ("add", "a,#!constbyte", ((char) -sym->stack) & 0xff);
emitcode ("mov", "sp,a");
- }
+ }
- if ((IFFUNC_ISREENT (sym->type) || options.stackAuto))
- {
- if (options.useXstack)
- {
+ if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+ (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+
+ if (options.useXstack) {
emitcode ("mov", "r0,%s", spname);
emitcode ("movx", "a,@r0");
emitcode ("mov", "_bp,a");
emitcode ("dec", "%s", spname);
- }
- else
- {
- emitcode ("pop", "_bp");
- }
- }
+ } else {
+ if (options.stack10bit) {
+ emitcode ("pop", "_bpx+1");
+ emitcode ("pop", "_bpx");
+ } else {
+ emitcode ("pop", "_bp");
+ }
+ }
+ }
/* restore the register bank */
if (FUNC_REGBANK (sym->type) || IFFUNC_ISISR (sym->type))
*/
emitcode ("pop", "psw");
}
- }
+ }
if (IFFUNC_ISISR (sym->type))
- {
+ { /* is ISR */
/* now we need to restore the registers */
/* if this isr has no bank i.e. is going to
registers :-) */
if (!FUNC_REGBANK (sym->type))
{
+ int i;
/* if this function does not call any other
function then we can be economical and
save only those registers that are used */
if (!IFFUNC_HASFCALL(sym->type))
{
- int i;
/* if any registers used */
if (sym->regsUsed)
/* this function has a function call cannot
determines register usage so we will have to pop the
entire bank */
+ if (options.parms_in_bank1) {
+ for (i = 7 ; i >= 0 ; i-- ) {
+ emitcode ("pop","%s",rb1regs[i]);
+ }
+ }
unsaveRBank (0, ic, FALSE);
}
}
}
+/*-----------------------------------------------------------------*/
+/* genJavaNativeRet - generate code for return JavaNative */
+/*-----------------------------------------------------------------*/
+static void genJavaNativeRet(iCode *ic)
+{
+ int i, size;
+
+ aopOp (IC_LEFT (ic), ic, FALSE,
+ AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE);
+ size = AOP_SIZE (IC_LEFT (ic));
+
+ assert (size <= 4);
+
+ /* it is assigned to GPR0-R3 then push them */
+ if (aopHasRegs(AOP(IC_LEFT(ic)),R0_IDX,R1_IDX) ||
+ aopHasRegs(AOP(IC_LEFT(ic)),R2_IDX,R3_IDX)) {
+ for (i = 0 ; i < size ; i++ ) {
+ emitcode ("push","%s",aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,FALSE));
+ }
+ for (i = (size-1) ; i >= 0 ; i--) {
+ emitcode ("pop","a%s",javaRet[i]);
+ }
+ } else {
+ for (i = 0 ; i < size ; i++)
+ emitcode ("mov","%s,%s",javaRet[i],aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,FALSE));
+ }
+ for (i = size ; i < 4 ; i++ )
+ emitcode ("mov","%s,#0",javaRet[i]);
+ return;
+}
+
/*-----------------------------------------------------------------*/
/* genRet - generate code for return statement */
/*-----------------------------------------------------------------*/
if (!IC_LEFT (ic))
goto jumpret;
+ /* if this is a JavaNative function then return
+ value in different register */
+ if (IFFUNC_ISJAVANATIVE(currFunc->type)) {
+ genJavaNativeRet(ic);
+ goto jumpret;
+ }
/* we have something to return then
move the return value into place */
- aopOp (IC_LEFT (ic), ic, FALSE, TRUE);
+ aopOp (IC_LEFT (ic), ic, FALSE,
+ (AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE));
size = AOP_SIZE (IC_LEFT (ic));
_startLazyDPSEvaluation ();
if (!(ic->next && ic->next->op == LABEL &&
IC_LABEL (ic->next) == returnLabel))
- emitcode ("ljmp", "%05d$", (returnLabel->key + 100));
+ emitcode ("ljmp", "!tlabel", (returnLabel->key + 100));
}
D (emitcode (";", "genLabel ");
);
- emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100));
+ emitcode ("", "!tlabeldef", (IC_LABEL (ic)->key + 100));
}
/*-----------------------------------------------------------------*/
{
D (emitcode (";", "genGoto ");
);
- emitcode ("ljmp", "%05d$", (IC_LABEL (ic)->key + 100));
+ emitcode ("ljmp", "!tlabel", (IC_LABEL (ic)->key + 100));
}
/*-----------------------------------------------------------------*/
ic = ic->prev;
count++;
+ /* If we have any pushes or pops, we cannot predict the distance.
+ I don't like this at all, this should be dealt with in the
+ back-end */
+ if (ic->op == IPUSH || ic->op == IPOP) {
+ return 0;
+ }
+
if (ic->op == LABEL && IC_LABEL (ic)->key == key)
{
/* printf("findLabelBackwards = %d\n", count); */
if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
+ if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) &&
+ AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) {
+ while (icount--) {
+ emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
+ }
+ return TRUE;
+ }
/* if increment 16 bits in register */
if (
AOP_TYPE (IC_LEFT (ic)) == AOP_REG &&
emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$"
+ emitcode ("cjne", "%s,#0,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
,tlbl->key + 100);
else
{
emitcode ("clr", "a");
- emitcode ("cjne", "a,%s,%05d$"
+ emitcode ("cjne", "a,%s,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
,tlbl->key + 100);
}
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$"
+ emitcode ("cjne", "%s,#0,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
,tlbl->key + 100);
else
- emitcode ("cjne", "a,%s,%05d$"
+ emitcode ("cjne", "a,%s,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
,tlbl->key + 100);
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$"
+ emitcode ("cjne", "%s,#0,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
,tlbl->key + 100);
else
{
- emitcode ("cjne", "a,%s,%05d$"
+ emitcode ("cjne", "a,%s,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
,tlbl->key + 100);
}
if (emitTlbl)
{
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
return TRUE;
}
+ if (AOP_TYPE(IC_RESULT(ic))==AOP_STR && IS_ITEMP(IC_RESULT(ic)) &&
+ !AOP_USESDPTR(IC_LEFT(ic)) && icount <= 5 && size <= 3 &&
+ options.model == MODEL_FLAT24 ) {
+
+ switch (size) {
+ case 3:
+ emitcode ("mov","dpx,%s",aopGet(AOP (IC_LEFT (ic)), 2, FALSE, FALSE, FALSE));
+ case 2:
+ emitcode ("mov","dph,%s",aopGet(AOP (IC_LEFT (ic)), 1, FALSE, FALSE, FALSE));
+ case 1:
+ emitcode ("mov","dpl,%s",aopGet(AOP (IC_LEFT (ic)), 0, FALSE, FALSE, FALSE));
+ break;
+ }
+ while (icount--) emitcode ("inc","dptr");
+ return TRUE;
+ }
+
+ if (AOP_INDPTRn(IC_LEFT(ic)) && AOP_INDPTRn(IC_RESULT(ic)) &&
+ AOP(IC_LEFT(ic))->aopu.dptr == AOP(IC_RESULT(ic))->aopu.dptr &&
+ icount <= 5 ) {
+ emitcode ("mov","dps,#!constbyte",AOP(IC_LEFT(ic))->aopu.dptr);
+ while (icount--) emitcode ("inc","dptr");
+ emitcode ("mov","dps,#0");
+ 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)
if (icount > 3)
{
MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, TRUE));
- emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
+ emitcode ("add", "a,#!constbyte", ((char) icount) & 0xff);
aopPut (AOP (IC_RESULT (ic)), "a", 0);
}
else
}
else
{
- emitcode ("jz", "%05d$", tlbl->key + 100);
+ emitcode ("jz", "!tlabel", tlbl->key + 100);
emitcode ("mov", "a,%s", one);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
outAcc (result);
}
}
{
symbol *lbl = newiTempLabel (NULL);
emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
- emitcode ("jnb", "%s,%05d$", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
+ emitcode ("jnb", "%s,!tlabel", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
outBitC (IC_RESULT (ic));
}
else
emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
emitcode ("rlc", "a");
emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode ("addc", "a,#0x00");
+ emitcode ("addc", "a,#0");
outAcc (IC_RESULT (ic));
}
}
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))) &&
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
{
- char buffer[5];
- sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
- aopPut (AOP (IC_RESULT (ic)), buffer, GPTRSIZE - 1);
+ char buff[5];
+ SNPRINTF (buff, sizeof(buff),
+ "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
+ aopPut (AOP (IC_RESULT (ic)), buff, GPTRSIZE - 1);
}
}
-#if 0 // AOP_OP_3 is deprecated; nobody likes Ack errors.
- // Please don't bring it back without a really good reason.
-// Macro to aopOp all three operands of an ic. Will fatal if this cannot be done
-// (because all three operands are in far space).
-#define AOP_OP_3(ic) \
- aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
- aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
- aopOp (IC_RESULT(ic),ic,TRUE, (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) || \
- (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
- AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
- { \
- /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
- fprintf(stderr, \
- "Ack: three operands in far space! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno); \
+// The guts of AOP_OP_3_NOFATAL. Generates the left & right opcodes of an IC,
+// generates the result if possible. If result is generated, returns TRUE; otherwise
+// returns false and caller must deal with fact that result isn't aopOp'd.
+bool aopOp3(iCode * ic)
+{
+ bool dp1InUse, dp2InUse;
+ bool useDp2;
+
+ // First, generate the right opcode. DPTR may be used if neither left nor result are
+ // of type AOP_STR.
+
+// D(emitcode(";", "aopOp3: AOP_IS_STR left: %s right: %s result: %s",
+// AOP_IS_STR(IC_LEFT(ic)) ? "true" : "false",
+// AOP_IS_STR(IC_RIGHT(ic)) ? "true" : "false",
+// AOP_IS_STR(IC_RESULT(ic)) ? "true" : "false");
+// );
+// D(emitcode(";", "aopOp3: AOP_IS_DPTRn left: %s right: %s result: %s",
+// AOP_IS_DPTRn(IC_LEFT(ic)) ? "true" : "false",
+// AOP_IS_DPTRn(IC_RIGHT(ic)) ? "true" : "false",
+// AOP_IS_DPTRn(IC_RESULT(ic)) ? "true" : "false");
+// );
+
+
+ // Right uses DPTR unless left or result is an AOP_STR.
+ aopOp (IC_RIGHT(ic),ic,FALSE, AOP_IS_STR(IC_LEFT(ic)) || AOP_IS_STR(IC_RESULT(ic)));
+
+ // if the right used DPTR, left MUST use DPTR2.
+ // if the right used DPTR2, left MUST use DPTR.
+ // if both are still available, we prefer to use DPTR. But if result is an AOP_STR
+ // and left is not an AOP_STR, then we will get better code if we use DP2 for left,
+ // enabling us to assign DPTR to result.
+
+ if (AOP_USESDPTR(IC_RIGHT(ic)))
+ {
+ useDp2 = TRUE;
}
-#endif
+ else if (AOP_USESDPTR2(IC_RIGHT(ic)))
+ {
+ useDp2 = FALSE;
+ }
+ else
+ {
+ if (AOP_IS_STR(IC_RESULT(ic)) && !AOP_IS_STR(IC_LEFT(ic)))
+ {
+ useDp2 = TRUE;
+ }
+ else
+ {
+ useDp2 = FALSE;
+ }
+ }
+
+ aopOp(IC_LEFT(ic), ic, FALSE, useDp2);
+
+ // We've op'd the left & right. So, if left or right are the same operand as result,
+ // we know aopOp will succeed, and we can just do it & bail.
+ if (isOperandEqual(IC_LEFT(ic),IC_RESULT(ic)) ||
+ isOperandEqual(IC_RIGHT(ic),IC_RESULT(ic)))
+ {
+// D(emitcode(";", "aopOp3: (left | right) & result equal"););
+ aopOp(IC_RESULT(ic),ic,TRUE, FALSE);
+ return TRUE;
+ }
+
+ // Note which dptrs are currently in use.
+ dp1InUse = AOP_USESDPTR(IC_LEFT(ic)) || AOP_USESDPTR(IC_RIGHT(ic));
+ dp2InUse = AOP_USESDPTR2(IC_LEFT(ic)) || AOP_USESDPTR2(IC_RIGHT(ic));
+
+ // OK, now if either left or right uses DPTR and the result is an AOP_STR, we cannot
+ // generate it.
+ if (dp1InUse && AOP_IS_STR(IC_RESULT(ic)))
+ {
+ return FALSE;
+ }
+
+ // Likewise, if left or right uses DPTR2 and the result is a DPTRn, we cannot generate it.
+ if (dp2InUse && AOP_IS_DPTRn(IC_RESULT(ic)))
+ {
+ return FALSE;
+ }
+
+ // or, if both dp1 & dp2 are in use and the result needs a dptr, we're out of luck
+ if (dp1InUse && dp2InUse && isOperandInFarSpace(IC_RESULT(ic)))
+ {
+ return FALSE;
+ }
+
+ aopOp (IC_RESULT(ic),ic,TRUE, dp1InUse);
+
+ // Some sanity checking...
+ if (dp1InUse && AOP_USESDPTR(IC_RESULT(ic)))
+ {
+ fprintf(stderr,
+ "Internal error: got unexpected DPTR (%s:%d %s:%d)\n",
+ __FILE__, __LINE__, ic->filename, ic->lineno);
+ emitcode(";", ">>> unexpected DPTR here.");
+ }
+
+ if (dp2InUse && AOP_USESDPTR2(IC_RESULT(ic)))
+ {
+ fprintf(stderr,
+ "Internal error: got unexpected DPTR2 (%s:%d %s:%d)\n",
+ __FILE__, __LINE__, ic->filename, ic->lineno);
+ emitcode(";", ">>> unexpected DPTR2 here.");
+ }
+
+ return TRUE;
+}
// Macro to aopOp all three operands of an ic. If this cannot be done,
// the IC_LEFT and IC_RIGHT operands will be aopOp'd, and the rc parameter
// will be set TRUE. The caller must then handle the case specially, noting
// that the IC_RESULT operand is not aopOp'd.
+//
#define AOP_OP_3_NOFATAL(ic, rc) \
- aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
- aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
- isOperandInFarSpace(IC_RESULT(ic))) \
- { \
- /* No can do; DPTR & DPTR2 in use, and we need another. */ \
- rc = TRUE; \
- } \
- else \
- { \
- aopOp (IC_RESULT(ic),ic,TRUE, (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) || \
- (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
- rc = FALSE; \
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
- AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
- { \
- /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
- fprintf(stderr, \
- "Ack: got unexpected DP2! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno); \
- } \
- }
+ do { rc = !aopOp3(ic); } while (0)
// aopOp the left & right operands of an ic.
#define AOP_OP_2(ic) \
- aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
- aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR));
+ aopOp (IC_RIGHT(ic),ic,FALSE, AOP_IS_STR(IC_LEFT(ic))); \
+ aopOp (IC_LEFT(ic),ic,FALSE, AOP_USESDPTR(IC_RIGHT(ic)));
// convienience macro.
#define AOP_SET_LOCALS(ic) \
D (emitcode (";", "genPlus "););
/* special cases :- */
-
+ if ( AOP_IS_STR(IC_LEFT(ic)) &&
+ isOperandLiteral(IC_RIGHT(ic)) && OP_SYMBOL(IC_RESULT(ic))->ruonly) {
+ aopOp (IC_RIGHT (ic), ic, TRUE, FALSE);
+ size = floatFromVal (AOP (IC_RIGHT(ic))->aopu.aop_lit);
+ if (size <= 9) {
+ while (size--) emitcode ("inc","dptr");
+ } else {
+ emitcode ("mov","a,dpl");
+ emitcode ("add","a,#!constbyte",size & 0xff);
+ emitcode ("mov","dpl,a");
+ emitcode ("mov","a,dph");
+ emitcode ("addc","a,#!constbyte",(size >> 8) & 0xff);
+ emitcode ("mov","dph,a");
+ emitcode ("mov","a,dpx");
+ emitcode ("addc","a,#!constbyte",(size >> 16) & 0xff);
+ emitcode ("mov","dpx,a");
+ }
+ freeAsmop (IC_RIGHT (ic), NULL, ic, FALSE);
+ return ;
+ }
+ if ( IS_SYMOP(IC_LEFT(ic)) &&
+ OP_SYMBOL(IC_LEFT(ic))->remat &&
+ isOperandInFarSpace(IC_RIGHT(ic))) {
+ operand *op = IC_RIGHT(ic);
+ IC_RIGHT(ic) = IC_LEFT(ic);
+ IC_LEFT(ic) = op;
+ }
+
AOP_OP_3_NOFATAL (ic, pushResult);
+
if (pushResult)
{
D (emitcode (";", "genPlus: must push result: 3 ops in far space"););
while (size--)
{
MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, TRUE));
- emitcode ("addc", "a,#00");
+ emitcode ("addc", "a,#0");
aopPut (AOP (IC_RESULT (ic)), "a", offset++);
}
_endLazyDPSEvaluation ();
if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
+ if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) &&
+ AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) {
+ while (icount--) {
+ emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
+ }
+ return TRUE;
+ }
/* if decrement 16 bits in register */
if (AOP_TYPE (IC_LEFT (ic)) == AOP_REG &&
AOP_TYPE (IC_RESULT (ic)) == AOP_REG &&
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
+ emitcode ("cjne", "%s,#!constbyte,!tlabel"
+ ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE), 0xff
,tlbl->key + 100);
else
{
- emitcode ("mov", "a,#0xff");
- emitcode ("cjne", "a,%s,%05d$"
+ emitcode ("mov", "a,#!constbyte",0xff);
+ emitcode ("cjne", "a,%s,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
,tlbl->key + 100);
}
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
+ emitcode ("cjne", "%s,#!constbyte,!tlabel"
+ ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE),0xff
,tlbl->key + 100);
else
{
- emitcode ("cjne", "a,%s,%05d$"
+ emitcode ("cjne", "a,%s,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
,tlbl->key + 100);
}
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
+ emitcode ("cjne", "%s,#!constbyte,!tlabel"
+ ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE),0xff
,tlbl->key + 100);
else
{
- emitcode ("cjne", "a,%s,%05d$"
+ emitcode ("cjne", "a,%s,!tlabel"
,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
,tlbl->key + 100);
}
}
if (emitTlbl)
{
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
return TRUE;
}
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
- emitcode ("jnb", "%s,%05d$", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
+ emitcode ("jnb", "%s,!tlabel", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
outBitC (IC_RESULT (ic));
}
else
{
emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir);
emitcode ("subb", "a,acc");
- emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
+ emitcode ("jnb", "%s,!tlabel", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
aopPut (AOP (IC_RESULT (ic)), "a", 0);
addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
}
static void
genMinus (iCode * ic)
{
- int size, offset = 0;
- int rSize;
- unsigned long lit = 0L;
- bool pushResult = FALSE;
+ int size, offset = 0;
+ int rSize;
+ unsigned long lit = 0L;
+ bool pushResult = FALSE;
- D (emitcode (";", "genMinus "););
+ D (emitcode (";", "genMinus "););
- aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
- aopOp (IC_RIGHT (ic), ic, FALSE, TRUE);
- if ((AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR) &&
- (AOP_TYPE (IC_RIGHT (ic)) == AOP_DPTR2))
- {
- pushResult = TRUE;
- }
- else
- {
- aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
+ AOP_OP_3_NOFATAL(ic, pushResult);
+ if (!pushResult)
+ {
/* special cases :- */
/* if both left & right are in bit space */
if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
/* if literal, add a,#-lit, else normal subb */
_startLazyDPSEvaluation ();
- while (size--)
- {
- MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
- if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
- emitcode ("subb", "a,%s",
- aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, FALSE));
- else
- {
+ while (size--) {
+ if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT) {
+ if (AOP_USESDPTR(IC_RIGHT(ic))) {
+ emitcode ("mov","b,%s",
+ aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, TRUE));
+ MOVA(aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
+ emitcode ("subb","a,b");
+ } else {
+ MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
+ emitcode ("subb", "a,%s",
+ aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, FALSE));
+ }
+ } else {
+ MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
/* first add without previous c */
if (!offset) {
- if (!size && lit==-1) {
- emitcode ("dec", "a");
- } else {
- emitcode ("add", "a,#0x%02x",
- (unsigned int) (lit & 0x0FFL));
- }
+ if (!size && lit==-1) {
+ emitcode ("dec", "a");
+ } else {
+ emitcode ("add", "a,#!constbyte",
+ (unsigned int) (lit & 0x0FFL));
+ }
} else {
- emitcode ("addc", "a,#0x%02x",
- (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+ emitcode ("addc", "a,#!constbyte",
+ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
}
- }
-
- if (pushResult)
- {
+ }
+
+ if (pushResult) {
emitcode ("push", "acc");
- }
- else
- {
+ } else {
aopPut (AOP (IC_RESULT (ic)), "a", offset);
- }
+ }
offset++;
- }
+ }
_endLazyDPSEvaluation ();
-
+
if (pushResult)
{
aopOp (IC_RESULT (ic), ic, TRUE, FALSE);
MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
emitcode ("mul", "ab");
- _G.accInUse++;
+ _G.accInUse++; _G.bInUse++;
aopOp(result, ic, TRUE, FALSE);
if (AOP_SIZE(result)<1 || AOP_SIZE(result)>2)
}
aopPut (AOP (result), "a", 0);
- _G.accInUse--;
+ _G.accInUse--; _G.bInUse--;
if (AOP_SIZE(result)==2)
{
aopPut (AOP (result), "b", 1);
MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
lbl=newiTempLabel(NULL);
- emitcode ("jnb", "acc.7,%05d$", lbl->key+100);
+ emitcode ("jnb", "acc.7,!tlabel", lbl->key+100);
// left side is negative, 8-bit two's complement, this fails for -128
emitcode ("setb", "F0"); // set sign flag
emitcode ("cpl", "a");
emitcode ("inc", "a");
- emitcode ("", "%05d$:", lbl->key+100);
+ emitcode ("", "!tlabeldef", lbl->key+100);
/* if literal */
if (AOP_TYPE(right)==AOP_LIT) {
/* AND literal negative */
if ((int) val < 0) {
emitcode ("cpl", "F0"); // complement sign flag
- emitcode ("mov", "b,#0x%02x", -val);
+ emitcode ("mov", "b,#!constbyte", -val);
} else {
- emitcode ("mov", "b,#0x%02x", val);
+ emitcode ("mov", "b,#!constbyte", val);
}
} else {
lbl=newiTempLabel(NULL);
emitcode ("mov", "b,a");
emitcode ("mov", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE, TRUE));
- emitcode ("jnb", "acc.7,%05d$", lbl->key+100);
+ emitcode ("jnb", "acc.7,!tlabel", lbl->key+100);
// right side is negative, 8-bit two's complement
emitcode ("cpl", "F0"); // complement sign flag
emitcode ("cpl", "a");
emitcode ("inc", "a");
- emitcode ("", "%05d$:", lbl->key+100);
+ emitcode ("", "!tlabeldef", lbl->key+100);
}
emitcode ("mul", "ab");
- _G.accInUse++;
+ _G.accInUse++;_G.bInUse++;
aopOp(result, ic, TRUE, FALSE);
if (AOP_SIZE(result)<1 || AOP_SIZE(result)>2)
}
lbl=newiTempLabel(NULL);
- emitcode ("jnb", "F0,%05d$", lbl->key+100);
+ emitcode ("jnb", "F0,!tlabel", lbl->key+100);
// only ONE op was negative, we have to do a 8/16-bit two's complement
emitcode ("cpl", "a"); // lsb
if (AOP_SIZE(result)==1) {
emitcode ("xch", "a,b");
}
- emitcode ("", "%05d$:", lbl->key+100);
+ emitcode ("", "!tlabeldef", lbl->key+100);
aopPut (AOP (result), "a", 0);
- _G.accInUse--;
+ _G.accInUse--;_G.bInUse--;
if (AOP_SIZE(result)==2) {
aopPut (AOP (result), "b", 1);
}
right = left;
left = t;
}
+ /* save EA bit in F1 */
+ lbl = newiTempLabel(NULL);
+ emitcode ("setb","F1");
+ emitcode ("jbc","EA,!tlabel",lbl->key+100);
+ emitcode ("clr","F1");
+ emitcode("","!tlabeldef",lbl->key+100);
+
/* load up MB with right */
if (!umult) {
emitcode("clr","F0");
if (val < 0) {
emitcode("setb","F0");
val = -val;
- }
- emitcode ("mov","mb,#0x%02x",(val >> 8) & 0xff);
- emitcode ("mov","mb,#0x%02x",val & 0xff);
+ }
+ emitcode ("mov","mb,#!constbyte",val & 0xff);
+ emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
} else {
lbl = newiTempLabel(NULL);
emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
- emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+ emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
emitcode ("xch", "a,b");
emitcode ("cpl","a");
emitcode ("add", "a,#1");
emitcode ("cpl", "a"); // msb
emitcode ("addc", "a,#0");
emitcode ("setb","F0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
emitcode ("mov","mb,b");
emitcode ("mov","mb,a");
}
lbl = newiTempLabel(NULL);
emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
- emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+ emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
emitcode ("xch", "a,b");
emitcode ("cpl","a");
emitcode ("add", "a,#1");
emitcode ("xch", "a,b");
emitcode ("cpl", "a"); // msb
emitcode ("addc","a,#0");
- emitcode ("jbc","F0,%05d$",lbl->key+100);
+ emitcode ("jbc","F0,!tlabel",lbl->key+100);
emitcode ("setb","F0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
emitcode ("mov","ma,b");
emitcode ("mov","ma,a");
} else {
}
/* wait for multiplication to finish */
lbl = newiTempLabel(NULL);
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
emitcode("mov","a,mcnt1");
- emitcode("anl","a,#0x80");
- emitcode("jnz","%05d$",lbl->key+100);
+ emitcode("anl","a,#!constbyte",0x80);
+ emitcode("jnz","!tlabel",lbl->key+100);
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (right, NULL, ic,TRUE);
MOVA("ma");
/* negate result if needed */
lbl = newiTempLabel(NULL);
- emitcode("jnb","F0,%05d$",lbl->key+100);
+ emitcode("jnb","F0,!tlabel",lbl->key+100);
emitcode("cpl","a");
emitcode("add","a,#1");
- emitcode("","%05d$:", lbl->key+100);
- aopPut(AOP(result),"a",0);
+ emitcode("","!tlabeldef", lbl->key+100);
+ if (AOP_TYPE(result) == AOP_ACC)
+ {
+ D(emitcode(";", "ACC special case."););
+ /* We know result is the only live aop, and
+ * it's obviously not a DPTR2, so AP is available.
+ */
+ emitcode("mov", "%s,acc", DP2_RESULT_REG);
+ }
+ else
+ {
+ aopPut(AOP(result),"a",0);
+ }
+
emitcode("pop","acc");
lbl = newiTempLabel(NULL);
- emitcode("jnb","F0,%05d$",lbl->key+100);
+ emitcode("jnb","F0,!tlabel",lbl->key+100);
emitcode("cpl","a");
emitcode("addc","a,#0");
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
aopPut(AOP(result),"a",1);
emitcode("pop","acc");
if (AOP_SIZE(result) >= 3) {
lbl = newiTempLabel(NULL);
- emitcode("jnb","F0,%05d$",lbl->key+100);
+ emitcode("jnb","F0,!tlabel",lbl->key+100);
emitcode("cpl","a");
emitcode("addc","a,#0");
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
aopPut(AOP(result),"a",2);
}
emitcode("pop","acc");
if (AOP_SIZE(result) >= 4) {
lbl = newiTempLabel(NULL);
- emitcode("jnb","F0,%05d$",lbl->key+100);
+ emitcode("jnb","F0,!tlabel",lbl->key+100);
emitcode("cpl","a");
emitcode("addc","a,#0");
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
aopPut(AOP(result),"a",3);
}
+ if (AOP_TYPE(result) == AOP_ACC)
+ {
+ /* We stashed the result away above. */
+ emitcode("mov", "acc,%s", DP2_RESULT_REG);
+ }
}
freeAsmop (result, NULL, ic, TRUE);
+
+ /* restore EA bit in F1 */
+ lbl = newiTempLabel(NULL);
+ emitcode ("jnb","F1,!tlabel",lbl->key+100);
+ emitcode ("setb","EA");
+ emitcode("","!tlabeldef",lbl->key+100);
return ;
}
l = aopGet (AOP (right), 0, FALSE, FALSE, TRUE);
MOVA (l);
lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+ emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
emitcode ("cpl", "a");
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
emitcode ("mov", "b,a");
/* sign adjust left side */
MOVA (l);
lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+ emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
emitcode ("cpl", "a");
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
/* now the division */
emitcode ("nop", "; workaround for DS80C390 div bug.");
emitcode ("pop", "acc");
/* if there was an over flow we don't
adjust the sign of the result */
- emitcode ("jb", "ov,%05d$", (lbl->key + 100));
- emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+ emitcode ("jb", "ov,!tlabel", (lbl->key + 100));
+ emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
CLRC;
emitcode ("clr", "a");
emitcode ("subb", "a,b");
emitcode ("mov", "b,a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
/* now we are done */
- _G.accInUse++;
+ _G.accInUse++; _G.bInUse++;
aopOp(result, ic, TRUE, FALSE);
aopPut (AOP (result), "b", 0);
{
aopPut (AOP (result), "a", offset++);
}
- _G.accInUse--;
+ _G.accInUse--; _G.bInUse--;
}
int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
symbol *lbl;
+ /* save EA bit in F1 */
+ lbl = newiTempLabel(NULL);
+ emitcode ("setb","F1");
+ emitcode ("jbc","EA,!tlabel",lbl->key+100);
+ emitcode ("clr","F1");
+ emitcode("","!tlabeldef",lbl->key+100);
+
/* load up MA with left */
if (!umult) {
emitcode("clr","F0");
lbl = newiTempLabel(NULL);
emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
- emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+ emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
emitcode ("xch", "a,b");
emitcode ("cpl","a");
emitcode ("add", "a,#1");
emitcode ("cpl", "a"); // msb
emitcode ("addc","a,#0");
emitcode ("setb","F0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
emitcode ("mov","ma,b");
emitcode ("mov","ma,a");
} else {
int val=floatFromVal (AOP (right)->aopu.aop_lit);
if (val < 0) {
lbl = newiTempLabel(NULL);
- emitcode ("jbc","F0,%05d$",lbl->key+100);
+ emitcode ("jbc","F0,!tlabel",lbl->key+100);
emitcode("setb","F0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
val = -val;
}
- emitcode ("mov","mb,#0x%02x",(val >> 8) & 0xff);
- emitcode ("mov","mb,#0x%02x",val & 0xff);
+ emitcode ("mov","mb,#!constbyte",val & 0xff);
+ emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
} else {
lbl = newiTempLabel(NULL);
emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
- emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+ emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
emitcode ("xch", "a,b");
emitcode ("cpl","a");
emitcode ("add", "a,#1");
emitcode ("xch", "a,b");
emitcode ("cpl", "a"); // msb
emitcode ("addc", "a,#0");
- emitcode ("jbc","F0,%05d$",lbl->key+100);
+ emitcode ("jbc","F0,!tlabel",lbl->key+100);
emitcode ("setb","F0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
emitcode ("mov","mb,b");
emitcode ("mov","mb,a");
}
/* wait for multiplication to finish */
lbl = newiTempLabel(NULL);
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
emitcode("mov","a,mcnt1");
- emitcode("anl","a,#0x80");
- emitcode("jnz","%05d$",lbl->key+100);
+ emitcode("anl","a,#!constbyte",0x80);
+ emitcode("jnz","!tlabel",lbl->key+100);
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (right, NULL, ic,TRUE);
MOVA("ma");
/* negate result if needed */
lbl = newiTempLabel(NULL);
- emitcode("jnb","F0,%05d$",lbl->key+100);
+ emitcode("jnb","F0,!tlabel",lbl->key+100);
emitcode("cpl","a");
emitcode("add","a,#1");
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
aopPut(AOP(result),"a",0);
emitcode("pop","acc");
lbl = newiTempLabel(NULL);
- emitcode("jnb","F0,%05d$",lbl->key+100);
+ emitcode("jnb","F0,!tlabel",lbl->key+100);
emitcode("cpl","a");
emitcode("addc","a,#0");
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
aopPut(AOP(result),"a",1);
}
freeAsmop (result, NULL, ic, TRUE);
+ /* restore EA bit in F1 */
+ lbl = newiTempLabel(NULL);
+ emitcode ("jnb","F1,!tlabel",lbl->key+100);
+ emitcode ("setb","EA");
+ emitcode("","!tlabeldef",lbl->key+100);
return ;
}
MOVA (l);
lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+ emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
emitcode ("cpl", "a");
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
emitcode ("mov", "b,a");
/* sign adjust left side */
MOVA (l);
lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+ emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
emitcode ("cpl", "a");
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
/* now the multiplication */
emitcode ("nop", "; workaround for DS80C390 div bug.");
emitcode ("pop", "acc");
/* if there was an over flow we don't
adjust the sign of the result */
- emitcode ("jb", "ov,%05d$", (lbl->key + 100));
- emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+ emitcode ("jb", "ov,!tlabel", (lbl->key + 100));
+ emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
CLRC;
emitcode ("clr", "a");
emitcode ("subb", "a,b");
emitcode ("mov", "b,a");
- emitcode ("", "%05d$:", (lbl->key + 100));
-
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
+
+ _G.bInUse++;
/* now we are done */
aopOp(result, ic, TRUE, FALSE);
aopPut (AOP (result), "b", 0);
+ _G.bInUse--;
}
symbol *lbl;
/* load up MA with left */
+ /* save EA bit in F1 */
+ lbl = newiTempLabel(NULL);
+ emitcode ("setb","F1");
+ emitcode ("jbc","EA,!tlabel",lbl->key+100);
+ emitcode ("clr","F1");
+ emitcode("","!tlabeldef",lbl->key+100);
+
if (!umult) {
lbl = newiTempLabel(NULL);
emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
- emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+ emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
emitcode ("xch", "a,b");
emitcode ("cpl","a");
emitcode ("add", "a,#1");
emitcode ("xch", "a,b");
emitcode ("cpl", "a"); // msb
emitcode ("addc","a,#0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
emitcode ("mov","ma,b");
emitcode ("mov","ma,a");
} else {
if (val < 0) {
val = -val;
}
- emitcode ("mov","mb,#0x%02x",(val >> 8) & 0xff);
- emitcode ("mov","mb,#0x%02x",val & 0xff);
+ emitcode ("mov","mb,#!constbyte",val & 0xff);
+ emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
} else {
lbl = newiTempLabel(NULL);
emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
- emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+ emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
emitcode ("xch", "a,b");
emitcode ("cpl","a");
emitcode ("add", "a,#1");
emitcode ("xch", "a,b");
emitcode ("cpl", "a"); // msb
emitcode ("addc", "a,#0");
- emitcode ("","%05d$:",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl->key+100);
emitcode ("mov","mb,b");
emitcode ("mov","mb,a");
}
/* wait for multiplication to finish */
lbl = newiTempLabel(NULL);
- emitcode("","%05d$:", lbl->key+100);
+ emitcode("","!tlabeldef", lbl->key+100);
emitcode("mov","a,mcnt1");
- emitcode("anl","a,#0x80");
- emitcode("jnz","%05d$",lbl->key+100);
+ emitcode("anl","a,#!constbyte",0x80);
+ emitcode("jnz","!tlabel",lbl->key+100);
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (right, NULL, ic,TRUE);
aopPut(AOP(result),"mb",1);
aopPut(AOP(result),"mb",0);
freeAsmop (result, NULL, ic, TRUE);
+
+ /* restore EA bit in F1 */
+ lbl = newiTempLabel(NULL);
+ emitcode ("jnb","F1,!tlabel",lbl->key+100);
+ emitcode ("setb","EA");
+ emitcode("","!tlabeldef",lbl->key+100);
return ;
}
symbol *tlbl = newiTempLabel (NULL);
char *inst;
- D (emitcode (";", "genIfxJump ");
- );
+ D (emitcode (";", "genIfxJump"););
/* if true label then we jump if condition
supplied is true */
(strcmp (jval, "c") == 0 ? "jc" : "jb")));
}
if (strcmp (inst, "jb") == 0 || strcmp (inst, "jnb") == 0)
- emitcode (inst, "%s,%05d$", jval, (tlbl->key + 100));
+ emitcode (inst, "%s,!tlabel", jval, (tlbl->key + 100));
else
- emitcode (inst, "%05d$", tlbl->key + 100);
- emitcode ("ljmp", "%05d$", jlbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode (inst, "!tlabel", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", jlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
/* mark the icode as generated */
ic->generated = 1;
/* if unsigned char cmp with lit, do cjne left,#right,zz */
if ((size == 1) && !sign &&
- (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR))
+ (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR && AOP_TYPE (left) != AOP_STR))
{
symbol *lbl = newiTempLabel (NULL);
- emitcode ("cjne", "%s,%s,%05d$",
+ emitcode ("cjne", "%s,%s,!tlabel",
aopGet (AOP (left), offset, FALSE, FALSE, FALSE),
aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
lbl->key + 100);
- emitcode ("", "%05d$:", lbl->key + 100);
+ emitcode ("", "!tlabeldef", lbl->key + 100);
}
else
{
CLRC;
while (size--)
{
- emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset);
+ //emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset);
MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
- emitcode (";", "genCmp #2");
+ //emitcode (";", "genCmp #2");
if (sign && (size == 0))
{
- emitcode (";", "genCmp #3");
- emitcode ("xrl", "a,#0x80");
+ //emitcode (";", "genCmp #3");
+ emitcode ("xrl", "a,#!constbyte",0x80);
if (AOP_TYPE (right) == AOP_LIT)
{
unsigned long lit = (unsigned long)
floatFromVal (AOP (right)->aopu.aop_lit);
- emitcode (";", "genCmp #3.1");
- emitcode ("subb", "a,#0x%02x",
+ //emitcode (";", "genCmp #3.1");
+ emitcode ("subb", "a,#!constbyte",
0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
}
else
{
- emitcode (";", "genCmp #3.2");
+ //emitcode (";", "genCmp #3.2");
if (AOP_NEEDSACC (right))
{
emitcode ("push", "acc");
}
emitcode ("mov", "b,%s", aopGet (AOP (right), offset++,
FALSE, FALSE, FALSE));
- emitcode ("xrl", "b,#0x80");
+ emitcode ("xrl", "b,#!constbyte",0x80);
if (AOP_NEEDSACC (right))
{
emitcode ("pop", "acc");
{
const char *s;
- emitcode (";", "genCmp #4");
+ //emitcode (";", "genCmp #4");
if (AOP_NEEDSACC (right))
{
/* Yuck!! */
- emitcode (";", "genCmp #4.1");
+ //emitcode (";", "genCmp #4.1");
emitcode ("xch", "a, b");
MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, TRUE));
emitcode ("xch", "a, b");
}
else
{
- emitcode (";", "genCmp #4.2");
+ //emitcode (";", "genCmp #4.2");
s = aopGet (AOP (right), offset++, FALSE, FALSE, FALSE);
}
{
char *l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
MOVA (l);
- emitcode ("cjne", "a,%s,%05d$",
+ emitcode ("cjne", "a,%s,!tlabel",
aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
lbl->key + 100);
offset++;
MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) &&
((unsigned int) ((lit >> (offset * 8)) & 0x0FFL) == 0))
- emitcode ("jnz", "%05d$", lbl->key + 100);
+ emitcode ("jnz", "!tlabel", lbl->key + 100);
else
- emitcode ("cjne", "a,%s,%05d$",
+ emitcode ("cjne", "a,%s,!tlabel",
aopGet (AOP (right), offset, FALSE, TRUE, FALSE),
lbl->key + 100);
offset++;
if (strcmp (l, "b"))
emitcode ("mov", "b,%s", l);
MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
- emitcode ("cjne", "a,b,%05d$", lbl->key + 100);
+ emitcode ("cjne", "a,b,!tlabel", lbl->key + 100);
offset++;
}
}
gencjneshort (left, right, lbl);
emitcode ("mov", "a,%s", one);
- emitcode ("sjmp", "%05d$", tlbl->key + 100);
- emitcode ("", "%05d$:", lbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", lbl->key + 100);
emitcode ("clr", "a");
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
/*-----------------------------------------------------------------*/
{
symbol *lbl = newiTempLabel (NULL);
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100));
+ emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
}
/* if true label then we jump if condition
supplied is true */
tlbl = newiTempLabel (NULL);
if (IC_TRUE (ifx))
{
- emitcode ("jnc", "%05d$", tlbl->key + 100);
- emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
+ emitcode ("jnc", "!tlabel", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
}
else
{
- emitcode ("jc", "%05d$", tlbl->key + 100);
- emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
+ emitcode ("jc", "!tlabel", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
}
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
else
{
gencjneshort (left, right, tlbl);
if (IC_TRUE (ifx))
{
- emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
else
{
symbol *lbl = newiTempLabel (NULL);
- emitcode ("sjmp", "%05d$", lbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
- emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
- emitcode ("", "%05d$:", lbl->key + 100);
+ emitcode ("sjmp", "!tlabel", lbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
+ emitcode ("", "!tlabeldef", lbl->key + 100);
}
}
/* mark the icode as generated */
{
symbol *lbl = newiTempLabel (NULL);
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100));
+ emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitcode ("", "!tlabeldef", (lbl->key + 100));
}
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
return NULL;
}
/*-----------------------------------------------------------------*/
-/* genAndOp - for && operation */
+/* hasInc - operand is incremented before any other use */
/*-----------------------------------------------------------------*/
-static void
-genAndOp (iCode * ic)
+static iCode *
+hasInc (operand *op, iCode *ic, int osize)
+{
+ sym_link *type = operandType(op);
+ sym_link *retype = getSpec (type);
+ iCode *lic = ic->next;
+ int isize ;
+
+ /* this could from a cast, e.g.: "(char xdata *) 0x7654;" */
+ if (!IS_SYMOP(op)) return NULL;
+
+ if (IS_BITVAR(retype)||!IS_PTR(type)) return NULL;
+ if (IS_AGGREGATE(type->next)) return NULL;
+ if (osize != (isize = getSize(type->next))) return NULL;
+
+ while (lic) {
+ /* if operand of the form op = op + <sizeof *op> */
+ if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
+ isOperandEqual(IC_RESULT(lic),op) &&
+ isOperandLiteral(IC_RIGHT(lic)) &&
+ operandLitValue(IC_RIGHT(lic)) == isize) {
+ return lic;
+ }
+ /* if the operand used or deffed */
+ if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
+ return NULL;
+ }
+ /* if GOTO or IFX */
+ if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
+ lic = lic->next;
+ }
+ return NULL;
+}
+
+/*-----------------------------------------------------------------*/
+/* genAndOp - for && operation */
+/*-----------------------------------------------------------------*/
+static void
+genAndOp (iCode * ic)
{
operand *left, *right, *result;
symbol *tlbl;
{
tlbl = newiTempLabel (NULL);
toBoolean (left);
- emitcode ("jz", "%05d$", tlbl->key + 100);
+ emitcode ("jz", "!tlabel", tlbl->key + 100);
toBoolean (right);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
{
tlbl = newiTempLabel (NULL);
toBoolean (left);
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
toBoolean (right);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
continueIfTrue (iCode * ic)
{
if (IC_TRUE (ic))
- emitcode ("ljmp", "%05d$", IC_TRUE (ic)->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_TRUE (ic)->key + 100);
ic->generated = 1;
}
jumpIfTrue (iCode * ic)
{
if (!IC_TRUE (ic))
- emitcode ("ljmp", "%05d$", IC_FALSE (ic)->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_FALSE (ic)->key + 100);
ic->generated = 1;
}
if (IC_TRUE (ic))
{
symbol *nlbl = newiTempLabel (NULL);
- emitcode ("sjmp", "%05d$", nlbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
- emitcode ("ljmp", "%05d$", IC_TRUE (ic)->key + 100);
- emitcode ("", "%05d$:", nlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", nlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_TRUE (ic)->key + 100);
+ emitcode ("", "!tlabeldef", nlbl->key + 100);
}
else
{
- emitcode ("ljmp", "%05d$", IC_FALSE (ic)->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_FALSE (ic)->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
ic->generated = 1;
}
int size, offset = 0;
unsigned long lit = 0L;
int bytelit = 0;
- char buffer[10];
+ char buff[10];
bool pushResult;
D (emitcode (";", "genAnd "););
{
if (ifx)
{
- sprintf (buffer, "acc.%d", posbit & 0x07);
- genIfxJump (ifx, buffer);
+ SNPRINTF (buff, sizeof(buff),
+ "acc.%d", posbit & 0x07);
+ genIfxJump (ifx, buff);
}
+ else
+ {
+ emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
+ }
goto release;
}
}
MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
// byte == 2^n ?
if ((posbit = isLiteralBit (bytelit)) != 0)
- emitcode ("jb", "acc.%d,%05d$", (posbit - 1) & 0x07, tlbl->key + 100);
+ emitcode ("jb", "acc.%d,!tlabel", (posbit - 1) & 0x07, tlbl->key + 100);
else
{
if (bytelit != 0x0FFL)
emitcode ("anl", "a,%s",
aopGet (AOP (right), offset, FALSE, TRUE, FALSE));
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
}
}
offset++;
if (size)
{
emitcode ("clr", "c");
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
// if(left & literal)
else
aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
}
}
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
offset++;
}
if (size)
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
outBitC (result);
}
else if (ifx)
symbol *tlbl = newiTempLabel (NULL);
if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
emitcode ("setb", "c");
- emitcode ("jb", "%s,%05d$",
+ emitcode ("jb", "%s,!tlabel",
AOP (left)->aopu.aop_dir, tlbl->key + 100);
toBoolean (right);
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
if ((AOP_TYPE (result) == AOP_CRY) && ifx)
{
jmpTrueOrFalse (ifx, tlbl);
else
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
}
}
outBitC (result);
// if(bit | ...)
else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c");
+ genIfxJump (ifx, "c");
goto release;
}
if (size)
{
symbol *tlbl = newiTempLabel (NULL);
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
else
{
emitcode ("orl", "a,%s",
aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
}
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
offset++;
}
if (size)
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
outBitC (result);
}
else if (ifx)
MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, TRUE));
if (sizer == 1)
// test the msb of the lsb
- emitcode ("anl", "a,#0xfe");
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("anl", "a,#!constbyte",0xfe);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
sizer--;
}
// val = (0,1)
emitcode ("rrc", "a");
}
- emitcode ("jnb", "%s,%05d$", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
+ emitcode ("jnb", "%s,!tlabel", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitcode ("", "!tlabeldef", (tlbl->key + 100));
}
// bit = c
// val = c
// if(!size && ifx), conditional oper: if(left ^ right)
symbol *tlbl = newiTempLabel (NULL);
int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+
if (size)
emitcode ("setb", "c");
while (sizer--)
emitcode ("xrl", "a,%s",
aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
} else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
- emitcode ("xrl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+ char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+ if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
+ {
+ emitcode("mov", "b,a");
+ rOp = "b";
+ }
+
+ MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+ emitcode ("xrl", "a,%s", rOp);
}
}
- emitcode ("jnz", "%05d$", tlbl->key + 100);
+ emitcode ("jnz", "!tlabel", tlbl->key + 100);
offset++;
}
if (size)
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
outBitC (result);
}
else if (ifx)
jmpTrueOrFalse (ifx, tlbl);
}
else
+ {
for (; (size--); offset++)
{
// normal case
offset);
continue;
}
- D (emitcode (";", "better literal XOR.");
- );
+ D (emitcode (";", "better literal XOR."););
MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
emitcode ("xrl", "a, %s", aopGet (AOP (right), offset,
FALSE, FALSE, FALSE));
}
aopPut (AOP (result), "a", offset);
}
+ }
+
}
release:
{
char *buffer, *bp, *bp1;
- D (emitcode (";", "genInline ");
- );
+ D (emitcode (";", "genInline "); );
_G.inLine += (!options.asmpeep);
- buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
- strcpy (buffer, IC_INLINE (ic));
+ buffer = Safe_strdup(IC_INLINE(ic));
+ bp = buffer;
+ bp1 = buffer;
/* emit each line as a code */
while (*bp)
else
{
emitcode ("rl", "a");
- emitcode ("anl", "a,#0x01");
+ emitcode ("anl", "a,#1");
outAcc (result);
}
/* rotate left accumulator */
AccRol (shCount);
/* and kill the lower order bits */
- emitcode ("anl", "a,#0x%02x", SLMask[shCount]);
+ emitcode ("anl", "a,#!constbyte", SLMask[shCount]);
}
}
}
/* rotate right accumulator */
AccRol (8 - shCount);
/* and kill the higher order bits */
- emitcode ("anl", "a,#0x%02x", SRMask[shCount]);
+ emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
}
}
}
/* rotate right accumulator */
AccRol (8 - shCount);
/* and kill the higher order bits */
- emitcode ("anl", "a,#0x%02x", SRMask[shCount]);
- emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
+ emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+ emitcode ("orl", "a,#!constbyte",
(unsigned char) ~SRMask[shCount]);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
}
}
AccRol (shCount); // BBBAAAAA:CCCCCDDD
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SLMask[shCount]); // BBB00000:CCCCCDDD
emitcode ("xch", "a,%s", x); // CCCCCDDD:BBB00000
emitcode ("xch", "a,%s", x); // DDDCCCCC:(BBB^DDD)CCCCC
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SLMask[shCount]); // DDD00000:(BBB^DDD)CCCCC
emitcode ("xch", "a,%s", x); // (BBB^DDD)CCCCC:DDD00000
break;
case 6: // AAAAAABB:CCCCCCDD
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000000BB:CCCCCCDD
emitcode ("mov", "c,acc.0"); // c = B
emitcode ("xch", "a,%s", x); // CCCCCCDD:000000BB
break;
case 7: // a:x <<= 7
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 0000000B:CCCCCCCD
emitcode ("mov", "c,acc.0"); // c = B
AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000CCCCC:BBBAAAAA
emitcode ("xrl", "a,%s", x); // BBB(CCCCC^AAAAA):BBBAAAAA
emitcode ("xch", "a,%s", x); // BBBAAAAA:BBB(CCCCC^AAAAA)
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000AAAAA:BBB(CCCCC^AAAAA)
emitcode ("xch", "a,%s", x); // BBB(CCCCC^AAAAA):000AAAAA
emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000000AA:BBBBBBCC
break;
emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 0000000A:BBBBBBBC
break;
AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000CCCCC:BBBAAAAA
emitcode ("xrl", "a,%s", x); // BBB(CCCCC^AAAAA):BBBAAAAA
emitcode ("xch", "a,%s", x); // BBBAAAAA:BBB(CCCCC^AAAAA)
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000AAAAA:BBB(CCCCC^AAAAA)
emitcode ("xch", "a,%s", x); // BBB(CCCCC^AAAAA):000AAAAA
emitcode ("xch", "a,%s", x); // 000SAAAA:BBBCCCCC
- emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
+ emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+ emitcode ("orl", "a,#!constbyte",
(unsigned char) ~SRMask[shCount]); // 111AAAAA:BBBCCCCC
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
break; // SSSSAAAA:BBBCCCCC
case 6: // AABBBBBB:CCDDDDDD
emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 000000AA:BBBBBBCC
- emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
+ emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+ emitcode ("orl", "a,#!constbyte",
(unsigned char) ~SRMask[shCount]); // 111111AA:BBBBBBCC
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
break;
case 7: // ABBBBBBB:CDDDDDDD
emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
SRMask[shCount]); // 0000000A:BBBBBBBC
- emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
+ emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+ emitcode ("orl", "a,#!constbyte",
(unsigned char) ~SRMask[shCount]); // 1111111A:BBBBBBBC
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
break;
default:
break;
aopOp(left, ic, FALSE, FALSE);
aopOp(result, ic, FALSE, (AOP_TYPE(left) == AOP_DPTR));
-#if 1 // debug spew
+#if 0 // debug spew
if (IS_SYMOP(left) && OP_SYMBOL(left)->aop)
{
emitcode(";", "left (%s) is %d", OP_SYMBOL(left)->rname, AOP_TYPE(left));
* but since I'm too lazy to fix that today, at least we can make
* some small improvement.
*/
- emitcode("mov", "b,#0x%02x",
+ emitcode("mov", "b,#!constbyte",
((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
}
else
l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
MOVA (l);
- emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
emitcode ("add", "a,acc");
- emitcode ("", "%05d$:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl1->key + 100);
+ emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
aopPut (AOP (result), "a", 0);
goto release;
}
reAdjustPreg (AOP (result));
- emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
l = aopGet (AOP (result), offset, FALSE, FALSE, TRUE);
MOVA (l);
emitcode ("add", "a,acc");
_endLazyDPSEvaluation ();
reAdjustPreg (AOP (result));
- emitcode ("", "%05d$:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl1->key + 100);
+ emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
release:
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
default:
break;
}
-
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
}
- return TRUE;
+ freeAsmop (left, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
+
+ return TRUE;
}
#endif
* but since I'm too lazy to fix that today, at least we can make
* some small improvement.
*/
- emitcode("mov", "b,#0x%02x",
+ emitcode("mov", "b,#!constbyte",
((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
}
else
{
l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
MOVA (l);
- emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
emitcode ("mov", "c,ov");
emitcode ("rrc", "a");
- emitcode ("", "%05d$:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl1->key + 100);
+ emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
aopPut (AOP (result), "a", 0);
goto release;
}
reAdjustPreg (AOP (result));
- emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
emitcode ("mov", "c,ov");
_startLazyDPSEvaluation ();
while (size--)
}
_endLazyDPSEvaluation ();
reAdjustPreg (AOP (result));
- emitcode ("", "%05d$:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl1->key + 100);
+ emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
release:
freeAsmop (left, NULL, ic, TRUE);
* but since I'm too lazy to fix that today, at least we can make
* some small improvement.
*/
- emitcode("mov", "b,#0x%02x",
+ emitcode("mov", "b,#!constbyte",
((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
}
else
{
l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
MOVA (l);
- emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
CLRC;
emitcode ("rrc", "a");
- emitcode ("", "%05d$:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl1->key + 100);
+ emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
aopPut (AOP (result), "a", 0);
goto release;
}
reAdjustPreg (AOP (result));
- emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
CLRC;
_startLazyDPSEvaluation ();
while (size--)
_endLazyDPSEvaluation ();
reAdjustPreg (AOP (result));
- emitcode ("", "%05d$:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl1->key + 100);
+ emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
release:
freeAsmop (left, NULL, ic, TRUE);
/* shift right acc */
AccRsh (shCnt);
- emitcode ("anl", "a,#0x%02x",
+ emitcode ("anl", "a,#!constbyte",
((unsigned char) -1) >> (8 - SPEC_BLEN (etype)));
aopPut (AOP (result), "a", offset);
return;
if (rlen)
{
- emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (rlen));
+ emitcode ("anl", "a,#!constbyte", ((unsigned char) -1) >> (rlen));
aopPut (AOP (result), "a", offset);
}
iCode * ic)
{
char *l;
- char buffer[256];
+ char buff[256];
int size, offset = 0;
aopOp (result, ic, TRUE, FALSE);
_startLazyDPSEvaluation ();
while (size--)
{
- if (offset)
- sprintf (buffer, "(%s + %d)", l + 1, offset);
- else
- sprintf (buffer, "%s", l + 1);
- aopPut (AOP (result), buffer, offset++);
+ if (offset)
+ {
+ SNPRINTF (buff, sizeof(buff),
+ "(%s + %d)", l + 1, offset);
+ }
+ else
+ {
+ SNPRINTF (buff, sizeof(buff),
+ "%s", l + 1);
+ }
+ aopPut (AOP (result), buff, offset++);
}
_endLazyDPSEvaluation ();
static void
genNearPointerGet (operand * left,
operand * result,
- iCode * ic)
+ iCode * ic,
+ iCode *pi)
{
asmop *aop = NULL;
regs *preg = NULL;
char *rname;
sym_link *rtype, *retype, *letype;
sym_link *ltype = operandType (left);
- char buffer[80];
+ char buff[80];
rtype = operandType (result);
retype = getSpec (rtype);
}
else
{
- sprintf (buffer, "@%s", rname);
- aopPut (AOP (result), buffer, offset);
+ SNPRINTF (buff, sizeof(buff), "@%s", rname);
+ aopPut (AOP (result), buff, offset);
}
offset++;
- if (size)
- emitcode ("inc", "%s", rname);
+ if (size || pi)
+ {
+ emitcode ("inc", "%s", rname);
+ }
}
}
if (aop)
{
/* we had to allocate for this iCode */
+ if (pi) { /* post increment present */
+ aopPut(AOP ( left ),rname,0);
+ }
freeAsmop (NULL, aop, ic, TRUE);
}
else
if (AOP_SIZE (result) > 1 &&
!OP_SYMBOL (left)->remat &&
(OP_SYMBOL (left)->liveTo > ic->seq ||
- ic->depth))
+ ic->depth) &&
+ !pi)
{
int size = AOP_SIZE (result) - 1;
while (size--)
/* done */
freeAsmop (result, NULL, ic, TRUE);
-
+ if (pi) pi->generated = 1;
}
/*-----------------------------------------------------------------*/
static void
genPagedPointerGet (operand * left,
operand * result,
- iCode * ic)
+ iCode * ic,
+ iCode * pi)
{
asmop *aop = NULL;
regs *preg = NULL;
offset++;
- if (size)
+ if (size || pi)
emitcode ("inc", "%s", rname);
}
}
if (aop)
{
/* we had to allocate for this iCode */
+ if (pi) aopPut ( AOP (left), rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
if (AOP_SIZE (result) > 1 &&
!OP_SYMBOL (left)->remat &&
(OP_SYMBOL (left)->liveTo > ic->seq ||
- ic->depth))
+ ic->depth) &&
+ !pi)
{
int size = AOP_SIZE (result) - 1;
while (size--)
/* done */
freeAsmop (result, NULL, ic, TRUE);
-
-
+ if (pi) pi->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void
genFarPointerGet (operand * left,
- operand * result, iCode * ic)
+ operand * result, iCode * ic, iCode *pi)
{
- int size, offset;
+ int size, offset, dopi=1;
sym_link *retype = getSpec (operandType (result));
sym_link *letype = getSpec (operandType (left));
D (emitcode (";", "genFarPointerGet");
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
- if (AOP_TYPE (left) != AOP_STR)
+ if (AOP_TYPE (left) != AOP_STR && !AOP_INDPTRn(left) )
{
/* if this is remateriazable */
if (AOP_TYPE (left) == AOP_IMMD)
emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
emitcode ("pop", "dph");
emitcode ("pop", "dpl");
+ dopi =0;
}
_endLazyDPSEvaluation ();
}
}
/* so dptr know contains the address */
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE, TRUE);
+ aopOp (result, ic, FALSE, (AOP_INDPTRn(left) ? FALSE : TRUE));
/* if bit then unpack */
- if (IS_BITVAR (retype) || IS_BITVAR (letype))
- genUnpackBits (result, "dptr", FPOINTER);
- else
+ if (IS_BITVAR (retype) || IS_BITVAR (letype)) {
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ }
+ genUnpackBits (result, "dptr", FPOINTER);
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(0);
+ }
+ } else
{
size = AOP_SIZE (result);
offset = 0;
- _startLazyDPSEvaluation ();
- while (size--)
- {
-
- genSetDPTR (0);
- _flushLazyDPS ();
-
- emitcode ("movx", "a,@dptr");
- if (size)
- emitcode ("inc", "dptr");
-
- aopPut (AOP (result), "a", offset++);
- }
- _endLazyDPSEvaluation ();
+ if (AOP_INDPTRn(left) && AOP_USESDPTR(result)) {
+ while (size--) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ emitcode ("movx", "a,@dptr");
+ if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+ emitcode ("inc", "dptr");
+ genSetDPTR (0);
+ aopPut (AOP (result), "a", offset++);
+ }
+ } else {
+ _startLazyDPSEvaluation ();
+ while (size--) {
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ } else {
+ genSetDPTR (0);
+ }
+ _flushLazyDPS ();
+
+ emitcode ("movx", "a,@dptr");
+ if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+ emitcode ("inc", "dptr");
+
+ aopPut (AOP (result), "a", offset++);
+ }
+ _endLazyDPSEvaluation ();
+ }
}
+ if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
+ if (!AOP_INDPTRn(left)) {
+ aopPut ( AOP (left), "dpl", 0);
+ aopPut ( AOP (left), "dph", 1);
+ if (options.model == MODEL_FLAT24)
+ aopPut ( AOP (left), "dpx", 2);
+ }
+ pi->generated = 1;
+ } else if ((OP_SYMBOL(left)->ruonly || AOP_INDPTRn(left)) &&
+ AOP_SIZE(result) > 1 &&
+ (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+
+ size = AOP_SIZE (result) - 1;
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ }
+ while (size--) emitcode ("lcall","__decdptr");
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(0);
+ }
+ }
+ freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* emitcodePointerGet - gget value from code space */
+/* genCodePointerGet - get value from code space */
/*-----------------------------------------------------------------*/
static void
-emitcodePointerGet (operand * left,
- operand * result, iCode * ic)
+genCodePointerGet (operand * left,
+ operand * result, iCode * ic, iCode *pi)
{
- int size, offset;
+ int size, offset, dopi=1;
sym_link *retype = getSpec (operandType (result));
aopOp (left, ic, FALSE, FALSE);
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
- if (AOP_TYPE (left) != AOP_STR)
+ if (AOP_TYPE (left) != AOP_STR && !AOP_INDPTRn(left))
{
/* if this is remateriazable */
if (AOP_TYPE (left) == AOP_IMMD)
emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
emitcode ("pop", "dph");
emitcode ("pop", "dpl");
+ dopi=0;
}
_endLazyDPSEvaluation ();
}
}
/* so dptr know contains the address */
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE, TRUE);
+ aopOp (result, ic, FALSE, (AOP_INDPTRn(left) ? FALSE : TRUE));
/* if bit then unpack */
- if (IS_BITVAR (retype))
- genUnpackBits (result, "dptr", CPOINTER);
- else
+ if (IS_BITVAR (retype)) {
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ }
+ genUnpackBits (result, "dptr", CPOINTER);
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(0);
+ }
+ } else
{
size = AOP_SIZE (result);
offset = 0;
-
- _startLazyDPSEvaluation ();
- while (size--)
- {
- genSetDPTR (0);
- _flushLazyDPS ();
-
- emitcode ("clr", "a");
- emitcode ("movc", "a,@a+dptr");
- if (size)
- emitcode ("inc", "dptr");
- aopPut (AOP (result), "a", offset++);
- }
- _endLazyDPSEvaluation ();
+ if (AOP_INDPTRn(left) && AOP_USESDPTR(result)) {
+ while (size--) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ emitcode ("clr", "a");
+ emitcode ("movc", "a,@a+dptr");
+ if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+ emitcode ("inc", "dptr");
+ genSetDPTR (0);
+ aopPut (AOP (result), "a", offset++);
+ }
+ } else {
+ _startLazyDPSEvaluation ();
+ while (size--)
+ {
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ } else {
+ genSetDPTR (0);
+ }
+ _flushLazyDPS ();
+
+ emitcode ("clr", "a");
+ emitcode ("movc", "a,@a+dptr");
+ if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+ emitcode ("inc", "dptr");
+ aopPut (AOP (result), "a", offset++);
+ }
+ _endLazyDPSEvaluation ();
+ }
}
-
+ if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
+ if (!AOP_INDPTRn(left)) {
+ aopPut ( AOP (left), "dpl", 0);
+ aopPut ( AOP (left), "dph", 1);
+ if (options.model == MODEL_FLAT24)
+ aopPut ( AOP (left), "dpx", 2);
+ }
+ pi->generated = 1;
+ } else if ((OP_SYMBOL(left)->ruonly || AOP_INDPTRn(left)) &&
+ AOP_SIZE(result) > 1 &&
+ (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+
+ size = AOP_SIZE (result) - 1;
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(AOP(left)->aopu.dptr);
+ }
+ while (size--) emitcode ("lcall","__decdptr");
+ if (AOP_INDPTRn(left)) {
+ genSetDPTR(0);
+ }
+ }
+
+ freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
static void
genGenPointerGet (operand * left,
- operand * result, iCode * ic)
+ operand * result, iCode * ic, iCode * pi)
{
int size, offset;
sym_link *retype = getSpec (operandType (result));
D (emitcode (";", "genGenPointerGet "); );
- aopOp (left, ic, FALSE, TRUE);
+ aopOp (left, ic, FALSE, (AOP_IS_STR(left) ? FALSE : TRUE));
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
if (AOP_TYPE (left) == AOP_IMMD)
{
emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, FALSE));
- emitcode ("mov", "b,#%d", pointerCode (retype));
+ if (AOP(left)->aopu.aop_immd.from_cast_remat)
+ emitcode ("mov", "b,%s",aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE, FALSE));
+ else
+ emitcode ("mov", "b,#%d", pointerCode (retype));
}
else
{ /* we need to get it byte by byte */
- _startLazyDPSEvaluation ();
- if (AOP(left)->type==AOP_DPTR2) {
- char *l;
- l=aopGet(AOP(left),0,FALSE,FALSE,TRUE);
- genSetDPTR(0);
- _flushLazyDPS();
- emitcode ("mov", "dpl,%s", l);
- l=aopGet(AOP(left),1,FALSE,FALSE,TRUE);
- genSetDPTR(0);
- _flushLazyDPS();
- emitcode ("mov", "dph,%s", l);
- if (options.model == MODEL_FLAT24) {
- l=aopGet(AOP(left),2,FALSE,FALSE,TRUE);
- genSetDPTR(0);
- _flushLazyDPS();
- emitcode ("mov", "dpx,%s", l);
- emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
- } else {
- emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
- }
- } else {
+ _startLazyDPSEvaluation ();
emitcode ("mov", "dpl,%s", aopGet (AOP(left),0,FALSE,FALSE,TRUE));
emitcode ("mov", "dph,%s", aopGet (AOP(left),1,FALSE,FALSE,TRUE));
if (options.model == MODEL_FLAT24) {
- emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
- emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
+ emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
+ emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
} else {
- emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
+ emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
}
- }
- _endLazyDPSEvaluation ();
+ _endLazyDPSEvaluation ();
}
}
- /* so dptr know contains the address */
- freeAsmop (left, NULL, ic, TRUE);
+
+ /* so dptr-b now contains the address */
+ _G.bInUse++;
aopOp (result, ic, FALSE, TRUE);
+ _G.bInUse--;
/* if bit then unpack */
if (IS_BITVAR (retype) || IS_BITVAR (letype))
+ {
genUnpackBits (result, "dptr", GPOINTER);
+ }
else
{
- size = AOP_SIZE (result);
- offset = 0;
+ size = AOP_SIZE (result);
+ offset = 0;
- while (size--)
+ while (size--)
{
- emitcode ("lcall", "__gptrget");
- aopPut (AOP (result), "a", offset++);
- if (size)
- emitcode ("inc", "dptr");
+ if (size)
+ {
+ // Get two bytes at a time, results in _AP & A.
+ // dptr will be incremented ONCE by __gptrgetWord.
+ //
+ // Note: any change here must be coordinated
+ // with the implementation of __gptrgetWord
+ // in device/lib/_gptrget.c
+ emitcode ("lcall", "__gptrgetWord");
+ aopPut (AOP (result), DP2_RESULT_REG, offset++);
+ aopPut (AOP (result), "a", offset++);
+ size--;
+ }
+ else
+ {
+ // Only one byte to get.
+ emitcode ("lcall", "__gptrget");
+ aopPut (AOP (result), "a", offset++);
+ }
+
+ if (size || (pi && AOP_TYPE (left) != AOP_IMMD))
+ {
+ emitcode ("inc", "dptr");
+ }
}
}
+ if (pi && AOP_TYPE (left) != AOP_IMMD) {
+ aopPut ( AOP (left), "dpl", 0);
+ aopPut ( AOP (left), "dph", 1);
+ if (options.model == MODEL_FLAT24) {
+ aopPut ( AOP (left), "dpx", 2);
+ aopPut ( AOP (left), "b", 3);
+ } else aopPut ( AOP (left), "b", 2);
+ pi->generated = 1;
+ } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
+ (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+
+ size = AOP_SIZE (result) - 1;
+ while (size--) emitcode ("lcall","__decdptr");
+ }
+
+ freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
/* genPointerGet - generate code for pointer get */
/*-----------------------------------------------------------------*/
static void
-genPointerGet (iCode * ic)
+genPointerGet (iCode * ic, iCode *pi)
{
operand *left, *result;
sym_link *type, *etype;
/* we have to go by the storage class */
p_type = PTR_TYPE (SPEC_OCLS (etype));
}
-
+ /* special case when cast remat */
+ if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
+ IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
+ left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
+ type = operandType (left);
+ p_type = DCL_TYPE (type);
+ }
/* now that we have the pointer type we assign
the pointer values */
switch (p_type)
case POINTER:
case IPOINTER:
- genNearPointerGet (left, result, ic);
+ genNearPointerGet (left, result, ic, pi);
break;
case PPOINTER:
- genPagedPointerGet (left, result, ic);
+ genPagedPointerGet (left, result, ic, pi);
break;
case FPOINTER:
- genFarPointerGet (left, result, ic);
+ genFarPointerGet (left, result, ic, pi);
break;
case CPOINTER:
- emitcodePointerGet (left, result, ic);
+ genCodePointerGet (left, result, ic, pi);
break;
case GPOINTER:
- genGenPointerGet (left, result, ic);
+ genGenPointerGet (left, result, ic, pi);
break;
}
break;
}
- emitcode ("anl", "a,#0x%02x", (unsigned char)
+ emitcode ("anl", "a,#!constbyte", (unsigned char)
((unsigned char) (0xFF << (blen + bstr)) |
(unsigned char) (0xFF >> (8 - bstr))));
emitcode ("orl", "a,b");
break;
}
- emitcode ("anl", "a,#0x%02x", ((unsigned char) -1 << rLen));
+ emitcode ("anl", "a,#!constbyte", ((unsigned char) -1 << rLen));
emitcode ("orl", "a,b");
}
iCode * ic)
{
int size, offset = 0;
- char *l, buffer[256];
+ char *l, buff[256];
aopOp (right, ic, FALSE, FALSE);
while (size--)
{
if (offset)
- sprintf (buffer, "(%s + %d)", l + 1, offset);
+ {
+ SNPRINTF (buff, sizeof(buff), "(%s + %d)", l + 1, offset);
+ }
else
- sprintf (buffer, "%s", l + 1);
- emitcode ("mov", "%s,%s", buffer,
+ {
+ SNPRINTF (buff, sizeof(buff), "%s", l + 1);
+ }
+
+ emitcode ("mov", "%s,%s", buff,
aopGet (AOP (right), offset++, FALSE, FALSE, FALSE));
}
static void
genNearPointerSet (operand * right,
operand * result,
- iCode * ic)
+ iCode * ic,
+ iCode * pi)
{
asmop *aop = NULL;
regs *preg = NULL;
else
rname = aopGet (AOP (result), 0, FALSE, FALSE, FALSE);
- freeAsmop (result, NULL, ic, TRUE);
aopOp (right, ic, FALSE, FALSE);
/* if bitfield then unpack the bits */
}
else
emitcode ("mov", "@%s,%s", rname, l);
- if (size)
+ if (size || pi)
emitcode ("inc", "%s", rname);
offset++;
}
if (aop)
{
/* we had to allocate for this iCode */
+ if (pi) aopPut (AOP (result),rname,0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
if (AOP_SIZE (right) > 1 &&
!OP_SYMBOL (result)->remat &&
(OP_SYMBOL (result)->liveTo > ic->seq ||
- ic->depth))
+ ic->depth) &&
+ !pi)
{
int size = AOP_SIZE (right) - 1;
while (size--)
}
/* done */
+ if (pi) pi->generated = 1;
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
static void
genPagedPointerSet (operand * right,
operand * result,
- iCode * ic)
+ iCode * ic,
+ iCode *pi)
{
asmop *aop = NULL;
regs *preg = NULL;
else
rname = aopGet (AOP (result), 0, FALSE, FALSE, FALSE);
- freeAsmop (result, NULL, ic, TRUE);
aopOp (right, ic, FALSE, FALSE);
/* if bitfield then unpack the bits */
MOVA (l);
emitcode ("movx", "@%s,a", rname);
- if (size)
+ if (size || pi)
emitcode ("inc", "%s", rname);
offset++;
/* now some housekeeping stuff */
if (aop)
{
+ if (pi) aopPut (AOP (result),rname,0);
/* we had to allocate for this iCode */
freeAsmop (NULL, aop, ic, TRUE);
}
if (AOP_SIZE (right) > 1 &&
!OP_SYMBOL (result)->remat &&
(OP_SYMBOL (result)->liveTo > ic->seq ||
- ic->depth))
+ ic->depth) &&
+ !pi)
{
int size = AOP_SIZE (right) - 1;
while (size--)
}
/* done */
+ if (pi) pi->generated = 1;
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
/*-----------------------------------------------------------------*/
static void
genFarPointerSet (operand * right,
- operand * result, iCode * ic)
+ operand * result, iCode * ic, iCode *pi)
{
- int size, offset;
+ int size, offset, dopi=1;
sym_link *retype = getSpec (operandType (right));
sym_link *letype = getSpec (operandType (result));
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
- if (AOP_TYPE (result) != AOP_STR)
+ if (AOP_TYPE (result) != AOP_STR && !AOP_INDPTRn(result))
{
/* if this is remateriazable */
if (AOP_TYPE (result) == AOP_IMMD)
emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
emitcode ("pop", "dph");
emitcode ("pop", "dpl");
+ dopi=0;
}
_endLazyDPSEvaluation ();
}
}
/* so dptr know contains the address */
- freeAsmop (result, NULL, ic, TRUE);
- aopOp (right, ic, FALSE, TRUE);
+ aopOp (right, ic, FALSE, (AOP_INDPTRn(result) ? FALSE : TRUE));
/* if bit then unpack */
- if (IS_BITVAR (retype) || IS_BITVAR (letype))
- genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", FPOINTER);
- else
- {
+ if (IS_BITVAR (retype) || IS_BITVAR (letype)) {
+ if (AOP_INDPTRn(result)) {
+ genSetDPTR(AOP(result)->aopu.dptr);
+ }
+ genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", FPOINTER);
+ if (AOP_INDPTRn(result)) {
+ genSetDPTR(0);
+ }
+ } else {
size = AOP_SIZE (right);
offset = 0;
-
- _startLazyDPSEvaluation ();
- while (size--)
- {
- char *l = aopGet (AOP (right), offset++, FALSE, FALSE, TRUE);
- MOVA (l);
-
- genSetDPTR (0);
- _flushLazyDPS ();
-
- emitcode ("movx", "@dptr,a");
- if (size)
- emitcode ("inc", "dptr");
- }
- _endLazyDPSEvaluation ();
- }
-
+ if (AOP_INDPTRn(result) && AOP_USESDPTR(right)) {
+ while (size--) {
+ char *l = aopGet (AOP (right), offset++, FALSE, FALSE, TRUE);
+ MOVA (l);
+
+ genSetDPTR(AOP(result)->aopu.dptr);
+ emitcode ("movx", "@dptr,a");
+ if (size || (dopi && pi && AOP_TYPE (result) != AOP_IMMD))
+ emitcode ("inc", "dptr");
+ genSetDPTR (0);
+ }
+ } else {
+ _startLazyDPSEvaluation ();
+ while (size--) {
+ char *l = aopGet (AOP (right), offset++, FALSE, FALSE, TRUE);
+ MOVA (l);
+
+ if (AOP_INDPTRn(result)) {
+ genSetDPTR(AOP(result)->aopu.dptr);
+ } else {
+ genSetDPTR (0);
+ }
+ _flushLazyDPS ();
+
+ emitcode ("movx", "@dptr,a");
+ if (size || (dopi && pi && AOP_TYPE (result) != AOP_IMMD))
+ emitcode ("inc", "dptr");
+ }
+ _endLazyDPSEvaluation ();
+ }
+ }
+
+ if (dopi && pi && AOP_TYPE (result) != AOP_IMMD) {
+ if (!AOP_INDPTRn(result)) {
+ aopPut (AOP(result),"dpl",0);
+ aopPut (AOP(result),"dph",1);
+ if (options.model == MODEL_FLAT24)
+ aopPut (AOP(result),"dpx",2);
+ }
+ pi->generated=1;
+ } else if ((OP_SYMBOL(result)->ruonly || AOP_INDPTRn(result)) &&
+ AOP_SIZE(right) > 1 &&
+ (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
+
+ size = AOP_SIZE (right) - 1;
+ if (AOP_INDPTRn(result)) {
+ genSetDPTR(AOP(result)->aopu.dptr);
+ }
+ while (size--) emitcode ("lcall","__decdptr");
+ if (AOP_INDPTRn(result)) {
+ genSetDPTR(0);
+ }
+ }
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
static void
genGenPointerSet (operand * right,
- operand * result, iCode * ic)
+ operand * result, iCode * ic, iCode *pi)
{
int size, offset;
sym_link *retype = getSpec (operandType (right));
sym_link *letype = getSpec (operandType (result));
- aopOp (result, ic, FALSE, TRUE);
+ aopOp (result, ic, FALSE, AOP_IS_STR(result) ? FALSE : TRUE);
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
if (AOP_TYPE (result) == AOP_IMMD)
{
emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
- emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
+ if (AOP(result)->aopu.aop_immd.from_cast_remat)
+ emitcode ("mov", "b,%s",aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, FALSE));
+ else
+ emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
}
else
{ /* we need to get it byte by byte */
_endLazyDPSEvaluation ();
}
/* so dptr know contains the address */
- freeAsmop (result, NULL, ic, TRUE);
aopOp (right, ic, FALSE, TRUE);
/* if bit then unpack */
_flushLazyDPS ();
emitcode ("lcall", "__gptrput");
- if (size)
+ if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
emitcode ("inc", "dptr");
}
_endLazyDPSEvaluation ();
}
+ if (pi && AOP_TYPE (result) != AOP_IMMD) {
+ aopPut (AOP(result),"dpl",0);
+ aopPut (AOP(result),"dph",1);
+ if (options.model == MODEL_FLAT24) {
+ aopPut (AOP(result),"dpx",2);
+ aopPut (AOP(result),"b",3);
+ } else {
+ aopPut (AOP(result),"b",2);
+ }
+ pi->generated=1;
+ } else if (OP_SYMBOL(result)->ruonly && AOP_SIZE(right) > 1 &&
+ (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
+
+ size = AOP_SIZE (right) - 1;
+ while (size--) emitcode ("lcall","__decdptr");
+ }
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
}
/* genPointerSet - stores the value into a pointer location */
/*-----------------------------------------------------------------*/
static void
-genPointerSet (iCode * ic)
+genPointerSet (iCode * ic, iCode *pi)
{
operand *right, *result;
sym_link *type, *etype;
/* we have to go by the storage class */
p_type = PTR_TYPE (SPEC_OCLS (etype));
}
+ /* special case when cast remat */
+ if (p_type == GPOINTER && OP_SYMBOL(result)->remat &&
+ IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) {
+ result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
+ type = operandType (result);
+ p_type = DCL_TYPE (type);
+ }
/* now that we have the pointer type we assign
the pointer values */
case POINTER:
case IPOINTER:
- genNearPointerSet (right, result, ic);
+ genNearPointerSet (right, result, ic, pi);
break;
case PPOINTER:
- genPagedPointerSet (right, result, ic);
+ genPagedPointerSet (right, result, ic, pi);
break;
case FPOINTER:
- genFarPointerSet (right, result, ic);
+ genFarPointerSet (right, result, ic, pi);
break;
case GPOINTER:
- genGenPointerSet (right, result, ic);
+ genGenPointerSet (right, result, ic, pi);
break;
+
+ default:
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "genPointerSet: illegal pointer type");
}
}
/* get the value into acc */
if (AOP_TYPE (cond) != AOP_CRY)
- toBoolean (cond);
+ {
+ toBoolean (cond);
+ }
else
- isbit = 1;
+ {
+ isbit = 1;
+ }
+
/* the result is now in the accumulator */
freeAsmop (cond, NULL, ic, TRUE);
/* if the condition is a bit variable */
if (isbit && IS_ITEMP (cond) &&
SPIL_LOC (cond))
- genIfxJump (ic, SPIL_LOC (cond)->rname);
+ {
+ genIfxJump (ic, SPIL_LOC (cond)->rname);
+ }
else if (isbit && !IS_ITEMP (cond))
- genIfxJump (ic, OP_SYMBOL (cond)->rname);
+ {
+ genIfxJump (ic, OP_SYMBOL (cond)->rname);
+ }
else
- genIfxJump (ic, "a");
+ {
+ genIfxJump (ic, "a");
+ }
ic->generated = 1;
}
/* if the operand is on the stack then we
need to get the stack offset of this
variable */
- if (sym->onStack)
- {
- /* if it has an offset then we need to compute
- it */
- if (sym->stack)
- {
- emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
- aopPut (AOP (IC_RESULT (ic)), "a", 0);
- }
- else
- {
- /* we can just move _bp */
- aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
- }
- /* fill the result with zero */
- size = AOP_SIZE (IC_RESULT (ic)) - 1;
-
-
- if (options.stack10bit && size < (FPTRSIZE - 1))
- {
- fprintf (stderr,
- "*** warning: pointer to stack var truncated.\n");
- }
-
- offset = 1;
- while (size--)
- {
- /* Yuck! */
- if (options.stack10bit && offset == 2)
- {
- aopPut (AOP (IC_RESULT (ic)), "#0x40", offset++);
- }
- else
- {
- aopPut (AOP (IC_RESULT (ic)), zero, offset++);
- }
- }
+ if (sym->onStack) {
+
+ /* if 10 bit stack */
+ if (options.stack10bit) {
+ char buff[10];
+ tsprintf(buff, sizeof(buff),
+ "#!constbyte",(options.stack_loc >> 16) & 0xff);
+ /* if it has an offset then we need to compute it */
+/* emitcode ("subb", "a,#!constbyte", */
+/* -((sym->stack < 0) ? */
+/* ((short) (sym->stack - _G.nRegsSaved)) : */
+/* ((short) sym->stack)) & 0xff); */
+/* emitcode ("mov","b,a"); */
+/* emitcode ("mov","a,#!constbyte",(-((sym->stack < 0) ? */
+/* ((short) (sym->stack - _G.nRegsSaved)) : */
+/* ((short) sym->stack)) >> 8) & 0xff); */
+ if (sym->stack) {
+ emitcode ("mov", "a,_bpx");
+ emitcode ("add", "a,#!constbyte", ((sym->stack < 0) ?
+ ((char) (sym->stack - _G.nRegsSaved)) :
+ ((char) sym->stack )) & 0xff);
+ emitcode ("mov", "b,a");
+ emitcode ("mov", "a,_bpx+1");
+ emitcode ("addc","a,#!constbyte", (((sym->stack < 0) ?
+ ((short) (sym->stack - _G.nRegsSaved)) :
+ ((short) sym->stack )) >> 8) & 0xff);
+ aopPut (AOP (IC_RESULT (ic)), "b", 0);
+ aopPut (AOP (IC_RESULT (ic)), "a", 1);
+ aopPut (AOP (IC_RESULT (ic)), buff, 2);
+ } else {
+ /* we can just move _bp */
+ aopPut (AOP (IC_RESULT (ic)), "_bpx", 0);
+ aopPut (AOP (IC_RESULT (ic)), "_bpx+1", 1);
+ aopPut (AOP (IC_RESULT (ic)), buff, 2);
+ }
+ } else {
+ /* if it has an offset then we need to compute it */
+ if (sym->stack) {
+ emitcode ("mov", "a,_bp");
+ emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
+ aopPut (AOP (IC_RESULT (ic)), "a", 0);
+ } else {
+ /* we can just move _bp */
+ aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
+ }
+ /* fill the result with zero */
+ size = AOP_SIZE (IC_RESULT (ic)) - 1;
+
+
+ if (options.stack10bit && size < (FPTRSIZE - 1)) {
+ fprintf (stderr,
+ "*** warning: pointer to stack var truncated.\n");
+ }
+ offset = 1;
+ while (size--) {
+ aopPut (AOP (IC_RESULT (ic)), zero, offset++);
+ }
+ }
goto release;
- }
+ }
/* object not on stack then we need the name */
size = AOP_SIZE (IC_RESULT (ic));
while (size--)
{
char s[SDCC_NAME_MAX];
- if (offset)
- sprintf (s, "#(%s >> %d)",
- sym->rname,
- offset * 8);
+ if (offset) {
+ switch (offset) {
+ case 1:
+ tsprintf(s, sizeof(s), "!his",sym->rname);
+ break;
+ case 2:
+ tsprintf(s, sizeof(s), "!hihis",sym->rname);
+ break;
+ case 3:
+ tsprintf(s, sizeof(s), "!hihihis",sym->rname);
+ break;
+ default: /* should not need this (just in case) */
+ SNPRINTF (s, sizeof(s), "#(%s >> %d)",
+ sym->rname,
+ offset * 8);
+ }
+ }
else
- sprintf (s, "#%s", sym->rname);
+ {
+ SNPRINTF (s, sizeof(s), "#%s", sym->rname);
+ }
+
aopPut (AOP (IC_RESULT (ic)), s, offset++);
}
tlbl = newiTempLabel (NULL);
if (firstpass || (count & 0xff))
{
- emitcode("mov", "b, #0x%x", count & 0xff);
+ emitcode("mov", "b, #!constbyte", count & 0xff);
}
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitcode ("", "!tlabeldef", tlbl->key + 100);
}
firstpass = FALSE;
val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff;
if (val != lastVal)
{
- emitcode("mov", "a, #0x%x", val);
+ emitcode("mov", "a, #!constbyte", val);
lastVal = val;
}
if (count > 1)
{
- emitcode("djnz", "b, %05d$", tlbl->key + 100);
+ emitcode("djnz", "b, !tlabel", tlbl->key + 100);
}
ix -= count;
/* We can use the '390 auto-toggle feature to good effect here. */
D(emitcode(";","genFarFarAssign (390 auto-toggle fun)"););
- emitcode("mov", "dps, #0x21"); /* Select DPTR2 & auto-toggle. */
+ emitcode("mov", "dps,#!constbyte",0x21); /* Select DPTR2 & auto-toggle. */
emitcode ("mov", "dptr,#%s", rSym->rname);
/* DP2 = result, DP1 = right, DP1 is current. */
while (size)
emitcode("inc", "dptr");
}
}
- emitcode("mov", "dps, #0");
+ emitcode("mov", "dps,#0");
freeAsmop (right, NULL, ic, FALSE);
#if 0
some alternative code for processors without auto-toggle
no time to test now, so later well put in...kpb
D(emitcode(";","genFarFarAssign (dual-dptr fun)"););
- emitcode("mov", "dps, #0x01"); /* Select DPTR2. */
+ emitcode("mov", "dps,#1"); /* Select DPTR2. */
emitcode ("mov", "dptr,#%s", rSym->rname);
/* DP2 = result, DP1 = right, DP1 is current. */
while (size)
emitcode("inc", "dptr");
emitcode("inc", "dps");
}
- emitcode("mov", "dps, #0");
+ emitcode("mov", "dps,#0");
freeAsmop (right, NULL, ic, FALSE);
#endif
}
freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
jtab = newiTempLabel (NULL);
- emitcode ("mov", "dptr,#%05d$", jtab->key + 100);
+ emitcode ("mov", "dptr,#!tlabel", jtab->key + 100);
emitcode ("jmp", "@a+dptr");
- emitcode ("", "%05d$:", jtab->key + 100);
+ emitcode ("", "!tlabeldef", jtab->key + 100);
/* now generate the jump labels */
for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
jtab = setNextItem (IC_JTLABELS (ic)))
- emitcode ("ljmp", "%05d$", jtab->key + 100);
+ emitcode ("ljmp", "!tlabel", jtab->key + 100);
}
/* pointer to generic pointer */
if (IS_GENPTR (ctype))
{
- char *l = zero;
-
if (IS_PTR (type))
{
p_type = DCL_TYPE (type);
_endLazyDPSEvaluation ();
/* the last byte depending on type */
- switch (p_type)
{
- case IPOINTER:
- case POINTER:
- l = zero;
- break;
- case FPOINTER:
- l = one;
- break;
- case CPOINTER:
- l = "#0x02";
- break;
- case PPOINTER:
- l = "#0x03";
- break;
-
- default:
- /* this should never happen */
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "got unknown pointer type");
- exit (1);
+ int gpVal = pointerTypeToGPByte(p_type, NULL, NULL);
+ char gpValStr[10];
+
+ if (gpVal == -1)
+ {
+ // pointerTypeToGPByte will have bitched.
+ exit(1);
+ }
+
+ SNPRINTF(gpValStr, sizeof(gpValStr), "#0x%d", gpVal);
+ aopPut (AOP (result), gpValStr, GPTRSIZE - 1);
}
- aopPut (AOP (result), l, GPTRSIZE - 1);
goto release;
}
}
emitcode ("dec", "%s", rByte);
aopPut(AOP(IC_RESULT(ic)), rByte, 0);
- emitcode ("jnz", "%05d$", lbl->key + 100);
+ emitcode ("jnz", "!tlabel", lbl->key + 100);
}
else if (IS_AOP_PREG (IC_RESULT (ic)))
{
emitcode ("dec", "%s",
aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
- emitcode ("jnz", "%05d$", lbl->key + 100);
+ emitcode ("jnz", "!tlabel", lbl->key + 100);
}
else
{
- emitcode ("djnz", "%s,%05d$", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, FALSE),
+ emitcode ("djnz", "%s,!tlabel", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, FALSE),
lbl->key + 100);
}
- emitcode ("sjmp", "%05d$", lbl1->key + 100);
- emitcode ("", "%05d$:", lbl->key + 100);
- emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
- emitcode ("", "%05d$:", lbl1->key + 100);
+ emitcode ("sjmp", "!tlabel", lbl1->key + 100);
+ emitcode ("", "!tlabeldef", lbl->key + 100);
+ emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
+ emitcode ("", "!tlabeldef", lbl1->key + 100);
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
ifx->generated = 1;
genReceive (iCode * ic)
{
- D (emitcode (";", "genReceive ");
- );
+ int size = getSize (operandType (IC_RESULT (ic)));
+ int offset = 0;
+ int rb1off ;
+
+ D (emitcode (";", "genReceive ");
+ );
- if (isOperandInFarSpace (IC_RESULT (ic)) &&
- (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
- IS_TRUE_SYMOP (IC_RESULT (ic))))
- {
- int size = getSize (operandType (IC_RESULT (ic)));
- int offset = fReturnSizeDS390 - size;
- while (size--)
+ if (ic->argreg == 1) { /* first parameter */
+ if (isOperandInFarSpace (IC_RESULT (ic)) &&
+ (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+ IS_TRUE_SYMOP (IC_RESULT (ic))))
+ {
+ offset = fReturnSizeDS390 - size;
+ while (size--)
+ {
+ emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeDS390 - offset - 1], "a") ?
+ fReturn[fReturnSizeDS390 - offset - 1] : "acc"));
+ offset++;
+ }
+ aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
+ size = AOP_SIZE (IC_RESULT (ic));
+ offset = 0;
+ while (size--)
+ {
+ emitcode ("pop", "acc");
+ aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+ }
+
+ } else {
+ _G.accInUse++;
+ aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
+ _G.accInUse--;
+ assignResultValue (IC_RESULT (ic));
+ }
+ } else { /* second receive onwards */
+ /* this gets a little tricky since unused recevies will be
+ eliminated, we have saved the reg in the type field . and
+ we use that to figure out which register to use */
+ aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
+ rb1off = ic->argreg;
+ while (size--) {
+ aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++);
+ }
+
+ }
+ freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMemcpyX2X - gen code for memcpy xdata to xdata */
+/*-----------------------------------------------------------------*/
+static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
+{
+ operand *from , *to , *count;
+ symbol *lbl;
+ bitVect *rsave;
+ int i;
+
+ /* we know it has to be 3 parameters */
+ assert (nparms == 3);
+
+ rsave = newBitVect(16);
+ /* save DPTR if it needs to be saved */
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
+ }
+ rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+ savermask(rsave);
+
+ to = parms[0];
+ from = parms[1];
+ count = parms[2];
+
+ aopOp (from, ic->next, FALSE, FALSE);
+
+ /* get from into DPTR1 */
+ emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, TRUE));
+ }
+
+ freeAsmop (from, NULL, ic, FALSE);
+ aopOp (to, ic, FALSE, FALSE);
+ /* get "to" into DPTR */
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE (to) != AOP_STR) {
+ /* if already in DPTR then we need to push */
+ if (AOP_TYPE(to) == AOP_DPTR) {
+ emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+ emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ emitcode ("pop", "dph");
+ emitcode ("pop", "dpl");
+ } else {
+ _startLazyDPSEvaluation ();
+ /* if this is remateriazable */
+ if (AOP_TYPE (to) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+ } else { /* we need to get it byte by byte */
+ emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ }
+ }
+ _endLazyDPSEvaluation ();
+ }
+ }
+ freeAsmop (to, NULL, ic, FALSE);
+ _G.dptrInUse = _G.dptr1InUse = 1;
+ aopOp (count, ic->next->next, FALSE,FALSE);
+ lbl =newiTempLabel(NULL);
+
+ /* now for the actual copy */
+ if (AOP_TYPE(count) == AOP_LIT &&
+ (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+ emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+ if (fromc) {
+ emitcode ("lcall","__bi_memcpyc2x_s");
+ } else {
+ emitcode ("lcall","__bi_memcpyx2x_s");
+ }
+ freeAsmop (count, NULL, ic, FALSE);
+ } else {
+ symbol *lbl1 = newiTempLabel(NULL);
+
+ emitcode (";"," Auto increment but no djnz");
+ emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+ emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+ freeAsmop (count, NULL, ic, FALSE);
+ emitcode ("mov", "dps,#!constbyte",0x21); /* Select DPTR2 & auto-toggle. */
+ emitcode ("","!tlabeldef",lbl->key+100);
+ if (fromc) {
+ emitcode ("clr","a");
+ emitcode ("movc", "a,@a+dptr");
+ } else
+ emitcode ("movx", "a,@dptr");
+ emitcode ("movx", "@dptr,a");
+ emitcode ("inc", "dptr");
+ emitcode ("inc", "dptr");
+ emitcode ("mov","a,b");
+ emitcode ("orl","a,_ap");
+ emitcode ("jz","!tlabel",lbl1->key+100);
+ emitcode ("mov","a,_ap");
+ emitcode ("add","a,#!constbyte",0xFF);
+ emitcode ("mov","_ap,a");
+ emitcode ("mov","a,b");
+ emitcode ("addc","a,#!constbyte",0xFF);
+ emitcode ("mov","b,a");
+ emitcode ("sjmp","!tlabel",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl1->key+100);
+ }
+ emitcode ("mov", "dps,#0");
+ _G.dptrInUse = _G.dptr1InUse = 0;
+ unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genMemcmpX2X - gen code for memcmp xdata to xdata */
+/*-----------------------------------------------------------------*/
+static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc)
+{
+ operand *from , *to , *count;
+ symbol *lbl,*lbl2;
+ bitVect *rsave;
+ int i;
+
+ /* we know it has to be 3 parameters */
+ assert (nparms == 3);
+
+ rsave = newBitVect(16);
+ /* save DPTR if it needs to be saved */
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
+ }
+ rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+ savermask(rsave);
+
+ to = parms[0];
+ from = parms[1];
+ count = parms[2];
+
+ aopOp (from, ic->next, FALSE, FALSE);
+
+ /* get from into DPTR1 */
+ emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, TRUE));
+ }
+
+ freeAsmop (from, NULL, ic, FALSE);
+ aopOp (to, ic, FALSE, FALSE);
+ /* get "to" into DPTR */
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE (to) != AOP_STR) {
+ /* if already in DPTR then we need to push */
+ if (AOP_TYPE(to) == AOP_DPTR) {
+ emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+ emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ emitcode ("pop", "dph");
+ emitcode ("pop", "dpl");
+ } else {
+ _startLazyDPSEvaluation ();
+ /* if this is remateriazable */
+ if (AOP_TYPE (to) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+ } else { /* we need to get it byte by byte */
+ emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ }
+ }
+ _endLazyDPSEvaluation ();
+ }
+ }
+ freeAsmop (to, NULL, ic, FALSE);
+ _G.dptrInUse = _G.dptr1InUse = 1;
+ aopOp (count, ic->next->next, FALSE,FALSE);
+ lbl =newiTempLabel(NULL);
+ lbl2 =newiTempLabel(NULL);
+
+ /* now for the actual compare */
+ if (AOP_TYPE(count) == AOP_LIT &&
+ (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+ emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+ if (fromc)
+ emitcode("lcall","__bi_memcmpc2x_s");
+ else
+ emitcode("lcall","__bi_memcmpx2x_s");
+ freeAsmop (count, NULL, ic, FALSE);
+ aopOp (IC_RESULT(ic), ic, FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ } else {
+ symbol *lbl1 = newiTempLabel(NULL);
+
+ emitcode("push","ar0");
+ emitcode (";"," Auto increment but no djnz");
+ emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+ emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+ freeAsmop (count, NULL, ic, FALSE);
+ emitcode ("mov", "dps,#!constbyte",0x21); /* Select DPTR2 & auto-toggle. */
+ emitcode ("","!tlabeldef",lbl->key+100);
+ if (fromc) {
+ emitcode ("clr","a");
+ emitcode ("movc", "a,@a+dptr");
+ } else
+ emitcode ("movx", "a,@dptr");
+ emitcode ("mov","r0,a");
+ emitcode ("movx", "a,@dptr");
+ emitcode ("clr","c");
+ emitcode ("subb","a,r0");
+ emitcode ("jnz","!tlabel",lbl2->key+100);
+ emitcode ("inc", "dptr");
+ emitcode ("inc", "dptr");
+ emitcode ("mov","a,b");
+ emitcode ("orl","a,_ap");
+ emitcode ("jz","!tlabel",lbl1->key+100);
+ emitcode ("mov","a,_ap");
+ emitcode ("add","a,#!constbyte",0xFF);
+ emitcode ("mov","_ap,a");
+ emitcode ("mov","a,b");
+ emitcode ("addc","a,#!constbyte",0xFF);
+ emitcode ("mov","b,a");
+ emitcode ("sjmp","!tlabel",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl1->key+100);
+ emitcode ("clr","a");
+ emitcode ("","!tlabeldef",lbl2->key+100);
+ aopOp (IC_RESULT(ic), ic, FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ emitcode("pop","ar0");
+ emitcode ("mov", "dps,#0");
+ }
+ _G.dptrInUse = _G.dptr1InUse = 0;
+ unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genInp - gen code for __builtin_inp read data from a mem mapped */
+/* port, first parameter output area second parameter pointer to */
+/* port third parameter count */
+/*-----------------------------------------------------------------*/
+static void genInp( iCode *ic, int nparms, operand **parms)
+{
+ operand *from , *to , *count;
+ symbol *lbl;
+ bitVect *rsave;
+ int i;
+
+ /* we know it has to be 3 parameters */
+ assert (nparms == 3);
+
+ rsave = newBitVect(16);
+ /* save DPTR if it needs to be saved */
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
+ }
+ rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+ savermask(rsave);
+
+ to = parms[0];
+ from = parms[1];
+ count = parms[2];
+
+ aopOp (from, ic->next, FALSE, FALSE);
+
+ /* get from into DPTR1 */
+ emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, TRUE));
+ }
+
+ freeAsmop (from, NULL, ic, FALSE);
+ aopOp (to, ic, FALSE, FALSE);
+ /* get "to" into DPTR */
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE (to) != AOP_STR) {
+ /* if already in DPTR then we need to push */
+ if (AOP_TYPE(to) == AOP_DPTR) {
+ emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+ emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ emitcode ("pop", "dph");
+ emitcode ("pop", "dpl");
+ } else {
+ _startLazyDPSEvaluation ();
+ /* if this is remateriazable */
+ if (AOP_TYPE (to) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+ } else { /* we need to get it byte by byte */
+ emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ }
+ }
+ _endLazyDPSEvaluation ();
+ }
+ }
+ freeAsmop (to, NULL, ic, FALSE);
+
+ _G.dptrInUse = _G.dptr1InUse = 1;
+ aopOp (count, ic->next->next, FALSE,FALSE);
+ lbl =newiTempLabel(NULL);
+
+ /* now for the actual copy */
+ if (AOP_TYPE(count) == AOP_LIT &&
+ (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+ emitcode (";","OH JOY auto increment with djnz (very fast)");
+ emitcode ("mov", "dps,#!constbyte",0x1); /* Select DPTR2 */
+ emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+ freeAsmop (count, NULL, ic, FALSE);
+ emitcode ("","!tlabeldef",lbl->key+100);
+ emitcode ("movx", "a,@dptr"); /* read data from port */
+ emitcode ("dec","dps"); /* switch to DPTR */
+ emitcode ("movx", "@dptr,a"); /* save into location */
+ emitcode ("inc", "dptr"); /* point to next area */
+ emitcode ("inc","dps"); /* switch to DPTR2 */
+ emitcode ("djnz","b,!tlabel",lbl->key+100);
+ } else {
+ symbol *lbl1 = newiTempLabel(NULL);
+
+ emitcode (";"," Auto increment but no djnz");
+ emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+ emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+ freeAsmop (count, NULL, ic, FALSE);
+ emitcode ("mov", "dps,#!constbyte",0x1); /* Select DPTR2 */
+ emitcode ("","!tlabeldef",lbl->key+100);
+ emitcode ("movx", "a,@dptr");
+ emitcode ("dec","dps"); /* switch to DPTR */
+ emitcode ("movx", "@dptr,a");
+ emitcode ("inc", "dptr");
+ emitcode ("inc","dps"); /* switch to DPTR2 */
+/* emitcode ("djnz","b,!tlabel",lbl->key+100); */
+/* emitcode ("djnz","_ap,!tlabel",lbl->key+100); */
+ emitcode ("mov","a,b");
+ emitcode ("orl","a,_ap");
+ emitcode ("jz","!tlabel",lbl1->key+100);
+ emitcode ("mov","a,_ap");
+ emitcode ("add","a,#!constbyte",0xFF);
+ emitcode ("mov","_ap,a");
+ emitcode ("mov","a,b");
+ emitcode ("addc","a,#!constbyte",0xFF);
+ emitcode ("mov","b,a");
+ emitcode ("sjmp","!tlabel",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl1->key+100);
+ }
+ emitcode ("mov", "dps,#0");
+ _G.dptrInUse = _G.dptr1InUse = 0;
+ unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genOutp - gen code for __builtin_inp write data to a mem mapped */
+/* port, first parameter output area second parameter pointer to */
+/* port third parameter count */
+/*-----------------------------------------------------------------*/
+static void genOutp( iCode *ic, int nparms, operand **parms)
+{
+ operand *from , *to , *count;
+ symbol *lbl;
+ bitVect *rsave;
+ int i;
+
+ /* we know it has to be 3 parameters */
+ assert (nparms == 3);
+
+ rsave = newBitVect(16);
+ /* save DPTR if it needs to be saved */
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
+ }
+ rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+ savermask(rsave);
+
+ to = parms[0];
+ from = parms[1];
+ count = parms[2];
+
+ aopOp (from, ic->next, FALSE, FALSE);
+
+ /* get from into DPTR1 */
+ emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, TRUE));
+ }
+
+ freeAsmop (from, NULL, ic, FALSE);
+ aopOp (to, ic, FALSE, FALSE);
+ /* get "to" into DPTR */
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE (to) != AOP_STR) {
+ /* if already in DPTR then we need to push */
+ if (AOP_TYPE(to) == AOP_DPTR) {
+ emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+ emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ emitcode ("pop", "dph");
+ emitcode ("pop", "dpl");
+ } else {
+ _startLazyDPSEvaluation ();
+ /* if this is remateriazable */
+ if (AOP_TYPE (to) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+ } else { /* we need to get it byte by byte */
+ emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ }
+ }
+ _endLazyDPSEvaluation ();
+ }
+ }
+ freeAsmop (to, NULL, ic, FALSE);
+
+ _G.dptrInUse = _G.dptr1InUse = 1;
+ aopOp (count, ic->next->next, FALSE,FALSE);
+ lbl =newiTempLabel(NULL);
+
+ /* now for the actual copy */
+ if (AOP_TYPE(count) == AOP_LIT &&
+ (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+ emitcode (";","OH JOY auto increment with djnz (very fast)");
+ emitcode ("mov", "dps,#!constbyte",0x0); /* Select DPTR */
+ emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+ emitcode ("","!tlabeldef",lbl->key+100);
+ emitcode ("movx", "a,@dptr"); /* read data from port */
+ emitcode ("inc","dps"); /* switch to DPTR2 */
+ emitcode ("movx", "@dptr,a"); /* save into location */
+ emitcode ("inc", "dptr"); /* point to next area */
+ emitcode ("dec","dps"); /* switch to DPTR */
+ emitcode ("djnz","b,!tlabel",lbl->key+100);
+ freeAsmop (count, NULL, ic, FALSE);
+ } else {
+ symbol *lbl1 = newiTempLabel(NULL);
+
+ emitcode (";"," Auto increment but no djnz");
+ emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+ emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+ freeAsmop (count, NULL, ic, FALSE);
+ emitcode ("mov", "dps,#!constbyte",0x0); /* Select DPTR */
+ emitcode ("","!tlabeldef",lbl->key+100);
+ emitcode ("movx", "a,@dptr");
+ emitcode ("inc", "dptr");
+ emitcode ("inc","dps"); /* switch to DPTR2 */
+ emitcode ("movx", "@dptr,a");
+ emitcode ("dec","dps"); /* switch to DPTR */
+ emitcode ("mov","a,b");
+ emitcode ("orl","a,_ap");
+ emitcode ("jz","!tlabel",lbl1->key+100);
+ emitcode ("mov","a,_ap");
+ emitcode ("add","a,#!constbyte",0xFF);
+ emitcode ("mov","_ap,a");
+ emitcode ("mov","a,b");
+ emitcode ("addc","a,#!constbyte",0xFF);
+ emitcode ("mov","b,a");
+ emitcode ("sjmp","!tlabel",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl1->key+100);
+ }
+ emitcode ("mov", "dps,#0");
+ _G.dptrInUse = _G.dptr1InUse = 0;
+ unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genSwapW - swap lower & high order bytes */
+/*-----------------------------------------------------------------*/
+static void genSwapW(iCode *ic, int nparms, operand **parms)
+{
+ operand *dest;
+ operand *src;
+ assert (nparms==1);
+
+ src = parms[0];
+ dest=IC_RESULT(ic);
+
+ assert(getSize(operandType(src))==2);
+
+ aopOp (src, ic, FALSE, FALSE);
+ emitcode ("mov","a,%s",aopGet(AOP(src),0,FALSE,FALSE,TRUE));
+ _G.accInUse++;
+ emitcode ("mov","b,%s",aopGet(AOP(src),1,FALSE,FALSE,FALSE));
+ _G.accInUse--;
+ freeAsmop (src, NULL, ic, FALSE);
+
+ aopOp (dest,ic, FALSE, FALSE);
+ aopPut(AOP(dest),"b",0);
+ aopPut(AOP(dest),"a",1);
+ freeAsmop (dest, NULL, ic, FALSE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMemsetX - gencode for memSetX data */
+/*-----------------------------------------------------------------*/
+static void genMemsetX(iCode *ic, int nparms, operand **parms)
+{
+ operand *to , *val , *count;
+ symbol *lbl;
+ char *l;
+ int i;
+ bitVect *rsave = NULL;
+
+ /* we know it has to be 3 parameters */
+ assert (nparms == 3);
+
+ to = parms[0];
+ val = parms[1];
+ count = parms[2];
+
+ /* save DPTR if it needs to be saved */
+ rsave = newBitVect(16);
+ for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+ if (bitVectBitValue(ic->rMask,i))
+ rsave = bitVectSetBit(rsave,i);
+ }
+ rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+ savermask(rsave);
+
+ aopOp (to, ic, FALSE, FALSE);
+ /* get "to" into DPTR */
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE (to) != AOP_STR) {
+ /* if already in DPTR then we need to push */
+ if (AOP_TYPE(to) == AOP_DPTR) {
+ emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+ emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+ if (options.model == MODEL_FLAT24)
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ emitcode ("pop", "dph");
+ emitcode ("pop", "dpl");
+ } else {
+ _startLazyDPSEvaluation ();
+ /* if this is remateriazable */
+ if (AOP_TYPE (to) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+ } else { /* we need to get it byte by byte */
+ emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+ emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+ if (options.model == MODEL_FLAT24) {
+ emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+ }
+ }
+ _endLazyDPSEvaluation ();
+ }
+ }
+ freeAsmop (to, NULL, ic, FALSE);
+
+ aopOp (val, ic->next->next, FALSE,FALSE);
+ aopOp (count, ic->next->next, FALSE,FALSE);
+ lbl =newiTempLabel(NULL);
+ /* now for the actual copy */
+ if (AOP_TYPE(count) == AOP_LIT &&
+ (int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+ l = aopGet(AOP (val), 0, FALSE, FALSE, TRUE);
+ emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+ MOVA(l);
+ emitcode ("","!tlabeldef",lbl->key+100);
+ emitcode ("movx", "@dptr,a");
+ emitcode ("inc", "dptr");
+ emitcode ("djnz","b,!tlabel",lbl->key+100);
+ } else {
+ symbol *lbl1 = newiTempLabel(NULL);
+
+ emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+ emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+ emitcode ("","!tlabeldef",lbl->key+100);
+ l = aopGet(AOP (val), 0, FALSE, FALSE, TRUE);
+ MOVA(l);
+ emitcode ("movx", "@dptr,a");
+ emitcode ("inc", "dptr");
+ emitcode ("mov","a,b");
+ emitcode ("orl","a,_ap");
+ emitcode ("jz","!tlabel",lbl1->key+100);
+ emitcode ("mov","a,_ap");
+ emitcode ("add","a,#!constbyte",0xFF);
+ emitcode ("mov","_ap,a");
+ emitcode ("mov","a,b");
+ emitcode ("addc","a,#!constbyte",0xFF);
+ emitcode ("mov","b,a");
+ emitcode ("sjmp","!tlabel",lbl->key+100);
+ emitcode ("","!tlabeldef",lbl1->key+100);
+ }
+ freeAsmop (count, NULL, ic, FALSE);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibLoadPrimitive - calls TINI api function to load primitive */
+/*-----------------------------------------------------------------*/
+static void genNatLibLoadPrimitive(iCode *ic, int nparms, operand **parms,int size)
+{
+ bitVect *rsave ;
+ operand *pnum, *result;
+ int i;
+
+ assert (nparms==1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ pnum = parms[0];
+ aopOp (pnum, ic, FALSE, FALSE);
+ emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,FALSE));
+ freeAsmop (pnum, NULL, ic, FALSE);
+ emitcode ("lcall","NatLib_LoadPrimitive");
+ aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE);
+ if (aopHasRegs(AOP(result),R0_IDX,R1_IDX) ||
+ aopHasRegs(AOP(result),R2_IDX,R3_IDX) ) {
+ for (i = (size-1) ; i >= 0 ; i-- ) {
+ emitcode ("push","a%s",javaRet[i]);
+ }
+ for (i=0; i < size ; i++ ) {
+ emitcode ("pop","a%s",aopGet(AOP(result),i,FALSE,FALSE,FALSE));
+ }
+ } else {
+ for (i = 0 ; i < size ; i++ ) {
+ aopPut(AOP(result),javaRet[i],i);
+ }
+ }
+ freeAsmop (result, NULL, ic, FALSE);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibLoadPointer - calls TINI api function to load pointer */
+/*-----------------------------------------------------------------*/
+static void genNatLibLoadPointer(iCode *ic, int nparms, operand **parms)
+{
+ bitVect *rsave ;
+ operand *pnum, *result;
+ int size = 3;
+ int i;
+
+ assert (nparms==1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ pnum = parms[0];
+ aopOp (pnum, ic, FALSE, FALSE);
+ emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,FALSE));
+ freeAsmop (pnum, NULL, ic, FALSE);
+ emitcode ("lcall","NatLib_LoadPointer");
+ aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE);
+ if (AOP_TYPE(result)!=AOP_STR) {
+ for (i = 0 ; i < size ; i++ ) {
+ aopPut(AOP(result),fReturn[i],i);
+ }
+ }
+ freeAsmop (result, NULL, ic, FALSE);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibInstallStateBlock - */
+/*-----------------------------------------------------------------*/
+static void genNatLibInstallStateBlock(iCode *ic, int nparms,
+ operand **parms, const char *name)
+{
+ bitVect *rsave ;
+ operand *psb, *handle;
+ assert (nparms==2);
+
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+ psb = parms[0];
+ handle = parms[1];
+
+ /* put pointer to state block into DPTR1 */
+ aopOp (psb, ic, FALSE, FALSE);
+ if (AOP_TYPE (psb) == AOP_IMMD) {
+ emitcode ("mov","dps,#1");
+ emitcode ("mov", "dptr,%s", aopGet (AOP (psb), 0, TRUE, FALSE, FALSE));
+ emitcode ("mov","dps,#0");
+ } else {
+ emitcode ("mov","dpl1,%s",aopGet(AOP(psb),0,FALSE,FALSE,FALSE));
+ emitcode ("mov","dph1,%s",aopGet(AOP(psb),1,FALSE,FALSE,FALSE));
+ emitcode ("mov","dpx1,%s",aopGet(AOP(psb),2,FALSE,FALSE,FALSE));
+ }
+ freeAsmop (psb, NULL, ic, FALSE);
+
+ /* put libraryID into DPTR */
+ emitcode ("mov","dptr,#LibraryID");
+
+ /* put handle into r3:r2 */
+ aopOp (handle, ic, FALSE, FALSE);
+ if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+ emitcode ("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode ("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ emitcode ("pop","ar3");
+ emitcode ("pop","ar2");
+ } else {
+ emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ }
+ freeAsmop (psb, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","NatLib_Install%sStateBlock",name);
+
+ /* put return value into place*/
+ _G.accInUse++;
+ aopOp (IC_RESULT(ic), ic, FALSE, FALSE);
+ _G.accInUse--;
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibRemoveStateBlock - */
+/*-----------------------------------------------------------------*/
+static void genNatLibRemoveStateBlock(iCode *ic,int nparms,const char *name)
+{
+ bitVect *rsave ;
+
+ assert(nparms==0);
+
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ /* put libraryID into DPTR */
+ emitcode ("mov","dptr,#LibraryID");
+ /* make the call */
+ emitcode ("lcall","NatLib_Remove%sStateBlock",name);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibGetStateBlock - */
+/*-----------------------------------------------------------------*/
+static void genNatLibGetStateBlock(iCode *ic,int nparms,
+ operand **parms,const char *name)
+{
+ bitVect *rsave ;
+ symbol *lbl = newiTempLabel(NULL);
+
+ assert(nparms==0);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ /* put libraryID into DPTR */
+ emitcode ("mov","dptr,#LibraryID");
+ /* make the call */
+ emitcode ("lcall","NatLib_Remove%sStateBlock",name);
+ emitcode ("jnz","!tlabel",lbl->key+100);
+
+ /* put return value into place */
+ aopOp(IC_RESULT(ic),ic,FALSE,FALSE);
+ if (aopHasRegs(AOP(IC_RESULT(ic)),R2_IDX,R3_IDX)) {
+ emitcode ("push","ar3");
+ emitcode ("push","ar2");
+ emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,FALSE));
+ emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,FALSE));
+ } else {
+ aopPut(AOP(IC_RESULT(ic)),"r2",0);
+ aopPut(AOP(IC_RESULT(ic)),"r3",1);
+ }
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ emitcode ("","!tlabeldef",lbl->key+100);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMMalloc - */
+/*-----------------------------------------------------------------*/
+static void genMMMalloc (iCode *ic,int nparms, operand **parms,
+ int size, const char *name)
+{
+ bitVect *rsave ;
+ operand *bsize;
+ symbol *rsym;
+ symbol *lbl = newiTempLabel(NULL);
+
+ assert (nparms == 1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ bsize=parms[0];
+ aopOp (bsize,ic,FALSE,FALSE);
+
+ /* put the size in R4-R2 */
+ if (aopHasRegs(AOP(bsize),R2_IDX, (size==3 ? R4_IDX: R3_IDX))) {
+ emitcode("push","%s",aopGet(AOP(bsize),0,FALSE,TRUE,FALSE));
+ emitcode("push","%s",aopGet(AOP(bsize),1,FALSE,TRUE,FALSE));
+ if (size==3) {
+ emitcode("push","%s",aopGet(AOP(bsize),2,FALSE,TRUE,FALSE));
+ emitcode("pop","ar4");
+ }
+ emitcode("pop","ar3");
+ emitcode("pop","ar2");
+ } else {
+ emitcode ("mov","r2,%s",aopGet(AOP(bsize),0,FALSE,TRUE,FALSE));
+ emitcode ("mov","r3,%s",aopGet(AOP(bsize),1,FALSE,TRUE,FALSE));
+ if (size==3) {
+ emitcode("mov","r4,%s",aopGet(AOP(bsize),2,FALSE,TRUE,FALSE));
+ }
+ }
+ freeAsmop (bsize, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","MM_%s",name);
+ emitcode ("jz","!tlabel",lbl->key+100);
+ emitcode ("mov","r2,#!constbyte",0xff);
+ emitcode ("mov","r3,#!constbyte",0xff);
+ emitcode ("","!tlabeldef",lbl->key+100);
+ /* we don't care about the pointer : we just save the handle */
+ rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp(IC_RESULT(ic),ic,FALSE,FALSE);
+ if (aopHasRegs(AOP(IC_RESULT(ic)),R2_IDX,R3_IDX)) {
+ emitcode ("push","ar3");
+ emitcode ("push","ar2");
+ emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,FALSE));
+ emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,FALSE));
+ } else {
+ aopPut(AOP(IC_RESULT(ic)),"r2",0);
+ aopPut(AOP(IC_RESULT(ic)),"r3",1);
+ }
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ }
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMDeref - */
+/*-----------------------------------------------------------------*/
+static void genMMDeref (iCode *ic,int nparms, operand **parms)
+{
+ bitVect *rsave ;
+ operand *handle;
+
+ assert (nparms == 1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ handle=parms[0];
+ aopOp (handle,ic,FALSE,FALSE);
+
+ /* put the size in R4-R2 */
+ if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+ emitcode("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ emitcode("pop","ar3");
+ emitcode("pop","ar2");
+ } else {
+ emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ }
+ freeAsmop (handle, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","MM_Deref");
+
{
- emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeDS390 - offset - 1], "a") ?
- fReturn[fReturnSizeDS390 - offset - 1] : "acc"));
- offset++;
+ symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+ if (AOP_TYPE(IC_RESULT(ic)) != AOP_STR) {
+ aopPut(AOP(IC_RESULT(ic)),"dpl",0);
+ aopPut(AOP(IC_RESULT(ic)),"dph",1);
+ aopPut(AOP(IC_RESULT(ic)),"dpx",2);
+ }
+ }
}
- aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
- size = AOP_SIZE (IC_RESULT (ic));
- offset = 0;
- while (size--)
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMUnrestrictedPersist - */
+/*-----------------------------------------------------------------*/
+static void genMMUnrestrictedPersist(iCode *ic,int nparms, operand **parms)
+{
+ bitVect *rsave ;
+ operand *handle;
+
+ assert (nparms == 1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ handle=parms[0];
+ aopOp (handle,ic,FALSE,FALSE);
+
+ /* put the size in R3-R2 */
+ if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+ emitcode("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ emitcode("pop","ar3");
+ emitcode("pop","ar2");
+ } else {
+ emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ }
+ freeAsmop (handle, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","MM_UnrestrictedPersist");
+
{
- emitcode ("pop", "acc");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+ symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ }
}
+ unsavermask(rsave);
+}
- }
- else
- {
- _G.accInUse++;
- aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
- _G.accInUse--;
- assignResultValue (IC_RESULT (ic));
- }
+/*-----------------------------------------------------------------*/
+/* genSystemExecJavaProcess - */
+/*-----------------------------------------------------------------*/
+static void genSystemExecJavaProcess(iCode *ic,int nparms, operand **parms)
+{
+ bitVect *rsave ;
+ operand *handle, *pp;
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ assert (nparms==2);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ pp = parms[0];
+ handle = parms[1];
+
+ /* put the handle in R3-R2 */
+ aopOp (handle,ic,FALSE,FALSE);
+ if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+ emitcode("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ emitcode("pop","ar3");
+ emitcode("pop","ar2");
+ } else {
+ emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+ emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+ }
+ freeAsmop (handle, NULL, ic, FALSE);
+
+ /* put pointer in DPTR */
+ aopOp (pp,ic,FALSE,FALSE);
+ if (AOP_TYPE(pp) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (pp), 0, TRUE, FALSE, FALSE));
+ } else if (AOP_TYPE(pp) != AOP_STR) { /* not already in dptr */
+ emitcode ("mov","dpl,%s",aopGet(AOP(pp),0,FALSE,FALSE,FALSE));
+ emitcode ("mov","dph,%s",aopGet(AOP(pp),1,FALSE,FALSE,FALSE));
+ emitcode ("mov","dpx,%s",aopGet(AOP(pp),2,FALSE,FALSE,FALSE));
+ }
+ freeAsmop (handle, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","System_ExecJavaProcess");
+
+ /* put result in place */
+ {
+ symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ }
+ }
+
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemRTCRegisters - */
+/*-----------------------------------------------------------------*/
+static void genSystemRTCRegisters(iCode *ic,int nparms, operand **parms,
+ char *name)
+{
+ bitVect *rsave ;
+ operand *pp;
+
+ assert (nparms==1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ pp=parms[0];
+ /* put pointer in DPTR */
+ aopOp (pp,ic,FALSE,FALSE);
+ if (AOP_TYPE (pp) == AOP_IMMD) {
+ emitcode ("mov","dps,#1");
+ emitcode ("mov", "dptr,%s", aopGet (AOP (pp), 0, TRUE, FALSE, FALSE));
+ emitcode ("mov","dps,#0");
+ } else {
+ emitcode ("mov","dpl1,%s",aopGet(AOP(pp),0,FALSE,FALSE,FALSE));
+ emitcode ("mov","dph1,%s",aopGet(AOP(pp),1,FALSE,FALSE,FALSE));
+ emitcode ("mov","dpx1,%s",aopGet(AOP(pp),2,FALSE,FALSE,FALSE));
+ }
+ freeAsmop (pp, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","System_%sRTCRegisters",name);
+
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemThreadSleep - */
+/*-----------------------------------------------------------------*/
+static void genSystemThreadSleep(iCode *ic,int nparms, operand **parms, char *name)
+{
+ bitVect *rsave ;
+ operand *to, *s;
+
+ assert (nparms==1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ to = parms[0];
+ aopOp(to,ic,FALSE,FALSE);
+ if (aopHasRegs(AOP(to),R2_IDX,R3_IDX) ||
+ aopHasRegs(AOP(to),R0_IDX,R1_IDX) ) {
+ emitcode ("push","%s",aopGet(AOP(to),0,FALSE,TRUE,FALSE));
+ emitcode ("push","%s",aopGet(AOP(to),1,FALSE,TRUE,FALSE));
+ emitcode ("push","%s",aopGet(AOP(to),2,FALSE,TRUE,FALSE));
+ emitcode ("push","%s",aopGet(AOP(to),3,FALSE,TRUE,FALSE));
+ emitcode ("pop","ar3");
+ emitcode ("pop","ar2");
+ emitcode ("pop","ar1");
+ emitcode ("pop","ar0");
+ } else {
+ emitcode ("mov","r0,%s",aopGet(AOP(to),0,FALSE,TRUE,FALSE));
+ emitcode ("mov","r1,%s",aopGet(AOP(to),1,FALSE,TRUE,FALSE));
+ emitcode ("mov","r2,%s",aopGet(AOP(to),2,FALSE,TRUE,FALSE));
+ emitcode ("mov","r3,%s",aopGet(AOP(to),3,FALSE,TRUE,FALSE));
+ }
+ freeAsmop (to, NULL, ic, FALSE);
+
+ /* suspend in acc */
+ s = parms[1];
+ aopOp(s,ic,FALSE,FALSE);
+ emitcode ("mov","a,%s",aopGet(AOP(s),0,FALSE,TRUE,FALSE));
+ freeAsmop (s, NULL, ic, FALSE);
+
+ /* make the call */
+ emitcode ("lcall","System_%s",name);
+
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemThreadResume - */
+/*-----------------------------------------------------------------*/
+static void genSystemThreadResume(iCode *ic,int nparms, operand **parms)
+{
+ bitVect *rsave ;
+ operand *tid,*pid;
+
+ assert (nparms==2);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ tid = parms[0];
+ pid = parms[1];
+
+ /* PID in R0 */
+ aopOp(pid,ic,FALSE,FALSE);
+ emitcode ("mov","r0,%s",aopGet(AOP(pid),0,FALSE,TRUE,FALSE));
+ freeAsmop (pid, NULL, ic, FALSE);
+
+ /* tid into ACC */
+ aopOp(tid,ic,FALSE,FALSE);
+ emitcode ("mov","a,%s",aopGet(AOP(tid),0,FALSE,TRUE,FALSE));
+ freeAsmop (tid, NULL, ic, FALSE);
+
+ emitcode ("lcall","System_ThreadResume");
+
+ /* put result into place */
+ {
+ symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ }
+ }
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemProcessResume - */
+/*-----------------------------------------------------------------*/
+static void genSystemProcessResume(iCode *ic,int nparms, operand **parms)
+{
+ bitVect *rsave ;
+ operand *pid;
+
+ assert (nparms==1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ pid = parms[0];
+
+ /* pid into ACC */
+ aopOp(pid,ic,FALSE,FALSE);
+ emitcode ("mov","a,%s",aopGet(AOP(pid),0,FALSE,TRUE,FALSE));
+ freeAsmop (pid, NULL, ic, FALSE);
+
+ emitcode ("lcall","System_ProcessResume");
+
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystem - */
+/*-----------------------------------------------------------------*/
+static void genSystem (iCode *ic,int nparms,char *name)
+{
+ assert(nparms == 0);
+
+ emitcode ("lcall","System_%s",name);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemPoll - */
+/*-----------------------------------------------------------------*/
+static void genSystemPoll(iCode *ic,int nparms, operand **parms,char *name)
+{
+ bitVect *rsave ;
+ operand *fp;
+
+ assert (nparms==1);
+ /* save registers that need to be saved */
+ savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+ ds390_rUmaskForOp (IC_RESULT(ic))));
+
+ fp = parms[0];
+ aopOp (fp,ic,FALSE,FALSE);
+ if (AOP_TYPE (fp) == AOP_IMMD) {
+ emitcode ("mov", "dptr,%s", aopGet (AOP (fp), 0, TRUE, FALSE, FALSE));
+ } else if (AOP_TYPE(fp) != AOP_STR) { /* not already in dptr */
+ emitcode ("mov","dpl,%s",aopGet(AOP(fp),0,FALSE,FALSE,FALSE));
+ emitcode ("mov","dph,%s",aopGet(AOP(fp),1,FALSE,FALSE,FALSE));
+ emitcode ("mov","dpx,%s",aopGet(AOP(fp),2,FALSE,FALSE,FALSE));
+ }
+ freeAsmop (fp, NULL, ic, FALSE);
+
+ emitcode ("lcall","System_%sPoll",name);
+
+ /* put result into place */
+ {
+ symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ }
+ }
+ unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemGetCurrentID - */
+/*-----------------------------------------------------------------*/
+static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *name)
+{
+ assert (nparms==0);
+
+ emitcode ("lcall","System_GetCurrent%sId",name);
+ /* put result into place */
+ {
+ symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+ if (rsym->liveFrom != rsym->liveTo) {
+ aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+ }
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* genBuiltIn - calls the appropriate function to generating code */
+/* for a built in function */
+/*-----------------------------------------------------------------*/
+static void genBuiltIn (iCode *ic)
+{
+ operand *bi_parms[MAX_BUILTIN_ARGS];
+ int nbi_parms;
+ iCode *bi_iCode;
+ symbol *bif;
+
+ /* get all the arguments for a built in function */
+ bi_iCode = getBuiltinParms(ic,&nbi_parms,bi_parms);
+
+ /* which function is it */
+ bif = OP_SYMBOL(IC_LEFT(bi_iCode));
+ if (strcmp(bif->name,"__builtin_memcpy_x2x")==0) {
+ genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,0);
+ } else if (strcmp(bif->name,"__builtin_memcpy_c2x")==0) {
+ genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,1);
+ } else if (strcmp(bif->name,"__builtin_memcmp_x2x")==0) {
+ genMemcmpX2X(bi_iCode,nbi_parms,bi_parms,0);
+ } else if (strcmp(bif->name,"__builtin_memcmp_c2x")==0) {
+ genMemcmpX2X(bi_iCode,nbi_parms,bi_parms,1);
+ } else if (strcmp(bif->name,"__builtin_memset_x")==0) {
+ genMemsetX(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"__builtin_inp")==0) {
+ genInp(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"__builtin_outp")==0) {
+ genOutp(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"__builtin_swapw")==0) {
+ genSwapW(bi_iCode,nbi_parms,bi_parms);
+ /* JavaNative builtIns */
+ } else if (strcmp(bif->name,"NatLib_LoadByte")==0) {
+ genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,1);
+ } else if (strcmp(bif->name,"NatLib_LoadShort")==0) {
+ genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,2);
+ } else if (strcmp(bif->name,"NatLib_LoadInt")==0) {
+ genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,4);
+ } else if (strcmp(bif->name,"NatLib_LoadPointer")==0) {
+ genNatLibLoadPointer(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"NatLib_InstallImmutableStateBlock")==0) {
+ genNatLibInstallStateBlock(bi_iCode,nbi_parms,bi_parms,"Immutable");
+ } else if (strcmp(bif->name,"NatLib_InstallEphemeralStateBlock")==0) {
+ genNatLibInstallStateBlock(bi_iCode,nbi_parms,bi_parms,"Ephemeral");
+ } else if (strcmp(bif->name,"NatLib_RemoveImmutableStateBlock")==0) {
+ genNatLibRemoveStateBlock(bi_iCode,nbi_parms,"Immutable");
+ } else if (strcmp(bif->name,"NatLib_RemoveEphemeralStateBlock")==0) {
+ genNatLibRemoveStateBlock(bi_iCode,nbi_parms,"Ephemeral");
+ } else if (strcmp(bif->name,"NatLib_GetImmutableStateBlock")==0) {
+ genNatLibGetStateBlock(bi_iCode,nbi_parms,bi_parms,"Immutable");
+ } else if (strcmp(bif->name,"NatLib_GetEphemeralStateBlock")==0) {
+ genNatLibGetStateBlock(bi_iCode,nbi_parms,bi_parms,"Ephemeral");
+ } else if (strcmp(bif->name,"MM_XMalloc")==0) {
+ genMMMalloc(bi_iCode,nbi_parms,bi_parms,3,"XMalloc");
+ } else if (strcmp(bif->name,"MM_Malloc")==0) {
+ genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"Malloc");
+ } else if (strcmp(bif->name,"MM_ApplicationMalloc")==0) {
+ genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"ApplicationMalloc");
+ } else if (strcmp(bif->name,"MM_Free")==0) {
+ genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"Free");
+ } else if (strcmp(bif->name,"MM_Deref")==0) {
+ genMMDeref(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"MM_UnrestrictedPersist")==0) {
+ genMMUnrestrictedPersist(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"System_ExecJavaProcess")==0) {
+ genSystemExecJavaProcess(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"System_GetRTCRegisters")==0) {
+ genSystemRTCRegisters(bi_iCode,nbi_parms,bi_parms,"Get");
+ } else if (strcmp(bif->name,"System_SetRTCRegisters")==0) {
+ genSystemRTCRegisters(bi_iCode,nbi_parms,bi_parms,"Set");
+ } else if (strcmp(bif->name,"System_ThreadSleep")==0) {
+ genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ThreadSleep");
+ } else if (strcmp(bif->name,"System_ThreadSleep_ExitCriticalSection")==0) {
+ genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ThreadSleep_ExitCriticalSection");
+ } else if (strcmp(bif->name,"System_ProcessSleep")==0) {
+ genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ProcessSleep");
+ } else if (strcmp(bif->name,"System_ProcessSleep_ExitCriticalSection")==0) {
+ genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ProcessSleep_ExitCriticalSection");
+ } else if (strcmp(bif->name,"System_ThreadResume")==0) {
+ genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"System_SaveThread")==0) {
+ genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"System_ThreadResume")==0) {
+ genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"System_ProcessResume")==0) {
+ genSystemProcessResume(bi_iCode,nbi_parms,bi_parms);
+ } else if (strcmp(bif->name,"System_SaveJavaThreadState")==0) {
+ genSystem(bi_iCode,nbi_parms,"SaveJavaThreadState");
+ } else if (strcmp(bif->name,"System_RestoreJavaThreadState")==0) {
+ genSystem(bi_iCode,nbi_parms,"RestoreJavaThreadState");
+ } else if (strcmp(bif->name,"System_ProcessYield")==0) {
+ genSystem(bi_iCode,nbi_parms,"ProcessYield");
+ } else if (strcmp(bif->name,"System_ProcessSuspend")==0) {
+ genSystem(bi_iCode,nbi_parms,"ProcessSuspend");
+ } else if (strcmp(bif->name,"System_RegisterPoll")==0) {
+ genSystemPoll(bi_iCode,nbi_parms,bi_parms,"Register");
+ } else if (strcmp(bif->name,"System_RemovePoll")==0) {
+ genSystemPoll(bi_iCode,nbi_parms,bi_parms,"Remove");
+ } else if (strcmp(bif->name,"System_GetCurrentThreadId")==0) {
+ genSystemGetCurrentID(bi_iCode,nbi_parms,bi_parms,"Thread");
+ } else if (strcmp(bif->name,"System_GetCurrentProcessId")==0) {
+ genSystemGetCurrentID(bi_iCode,nbi_parms,bi_parms,"Process");
+ } else {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"unknown builtin function encountered\n");
+ return ;
+ }
+ return ;
}
/*-----------------------------------------------------------------*/
int cln = 0;
lineHead = lineCurr = NULL;
-
+ dptrn[1][0] = "dpl1";
+ dptrn[1][1] = "dph1";
+ dptrn[1][2] = "dpx1";
+
if (options.model == MODEL_FLAT24) {
fReturnSizeDS390 = 5;
fReturn = fReturn24;
fReturn = fReturn16;
options.stack10bit=0;
}
-#if 0
- //REMOVE ME!!!
+#if 1
/* print the allocation information */
if (allocInfo)
printAllocInfo (currFunc, codeOutFile);
for (ic = lic; ic; ic = ic->next)
{
- if (cln != ic->lineno)
+ if (ic->lineno && cln != ic->lineno)
{
if (options.debug)
{
ic->level, ic->block);
_G.debugLine = 0;
}
- emitcode (";", "%s %d", ic->filename, ic->lineno);
+ if (!options.noCcodeInAsm) {
+ emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
+ printCLine(ic->filename, ic->lineno));
+ }
cln = ic->lineno;
}
+ if (options.iCodeInAsm) {
+ emitcode("", ";ic:%d: %s", ic->key, printILine(ic));
+ }
/* if the result is marked as
spilt and rematerializable or code for
this has already been generated then
break;
case GET_VALUE_AT_ADDRESS:
- genPointerGet (ic);
+ genPointerGet (ic,hasInc(IC_LEFT(ic),ic, getSize(operandType(IC_RESULT(ic)))));
break;
case '=':
if (POINTER_SET (ic))
- genPointerSet (ic);
+ genPointerSet (ic,hasInc(IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic)))));
else
genAssign (ic);
break;
break;
case SEND:
- addSet (&_G.sendSet, ic);
+ if (ic->builtinSEND) genBuiltIn(ic);
+ else addSet (&_G.sendSet, ic);
break;
case ARRAYINIT: