/*-------------------------------------------------------------------------
- SDCCgen51.c - source file for code generation for 8051
-
+ gen.c - source file for code generation for pic
+
Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
and - Jean-Louis VERN.jlvern@writeme.com (1999)
Bug Fixes - Wojciech Stryjewski wstryj1@tiger.lsu.edu (1999 v2.1.9a)
PIC port - Scott Dattalo scott@dattalo.com (2000)
-
+ cont'd - Raphael Neider <rneider AT web.de> (2005)
+
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
+
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding!
-
+
Notes:
000123 mlh Moved aopLiteral to SDCCglue.c to help the split
Made everything static
#include <string.h>
#include <ctype.h>
#include "SDCCglobl.h"
-#include "newalloc.h"
-
-#if defined(_MSC_VER)
-#define __FUNCTION__ __FILE__
-#endif
-
-#ifdef HAVE_SYS_ISA_DEFS_H
-#include <sys/isa_defs.h>
-#else
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER)
-#warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
-#warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
-#endif
-#endif
-#endif
+#include "newalloc.h"
#include "common.h"
#include "SDCCpeeph.h"
#include "ralloc.h"
+#include "pcode.h"
#include "gen.h"
-
-//char *aopLiteral (value *val, int offset);
-char *pic14aopLiteral (value * val, int offset);
-
-/* 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";
+#include "glue.h"
+
+/* The PIC port(s) need not differentiate between POINTER and FPOINTER. */
+#define PIC_IS_DATA_PTR(x) (IS_DATA_PTR(x) || IS_FARPTR(x))
+#define PIC_IS_FARPTR(x) (PIC_IS_DATA_PTR(x))
+
+extern void genUMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
+extern void genSMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
+void genMult8X8_8 (operand *, operand *,operand *);
+extern void printpBlock(FILE *of, pBlock *pb);
+
+static int labelOffset=0;
+extern int debug_verbose;
+extern int pic14_hasInterrupt;
+//static int optimized_for_speed = 0;
+
+/* max_key keeps track of the largest label number used in
+a function. This is then used to adjust the label offset
+for the next function.
+*/
+static int max_key=0;
+static int GpsuedoStkPtr=0;
+static int pic14_inISR = 0;
+
+pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func);
+extern char *get_op( pCodeOp *pcop,char *buff,size_t buf_size);
+const char *AopType(short type);
+
+#define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0x00ff)
+
+/* 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 *spname = "sp";
-char *fReturnpic14[] =
-{"fsr", "dph", "b", "a"};
-//char *fReturn390[] = {"dpl","dph","dpx", "b","a" };
-static unsigned fReturnSize = 4; /* shared with ralloc.c */
+char *fReturnpic14[] = {"temp1","temp2","temp3","temp4" };
+unsigned fReturnSizePic = 4; /* shared with ralloc.c */
static char **fReturn = fReturnpic14;
-static char *accUse[] =
-{"a", "b"};
+//static char *accUse[] = {"a","b"};
//static short rbank = -1;
-static struct
- {
- short r0Pushed;
- short r1Pushed;
- short accInUse;
- short inLine;
- short debugLine;
- short nRegsSaved;
- set *sendSet;
- }
-_G;
-
-extern int pic14_ptrRegReq;
+static struct {
+ short r0Pushed;
+ short r1Pushed;
+ short accInUse;
+ short inLine;
+ short debugLine;
+ short nRegsSaved;
+ set *sendSet;
+} _G;
+
+/* Resolved ifx structure. This structure stores information
+about an iCode ifx that makes it easier to generate code.
+*/
+typedef struct resolvedIfx {
+ symbol *lbl; /* pointer to a label */
+ int condition; /* true or false ifx */
+ int generated; /* set true when the code associated with the ifx
+ * is generated */
+} resolvedIfx;
+
+extern int pic14_ptrRegReq ;
extern int pic14_nRegs;
-extern FILE *codeOutFile;
-static void saverbank (int, iCode *, bool);
-#define RESULTONSTACK(x) \
- (IC_RESULT(x) && IC_RESULT(x)->aop && \
- IC_RESULT(x)->aop->type == AOP_STK )
-
-#define MOVA(x) if (strcmp(x,"a") && strcmp(x,"acc")) emitcode(";XXX mov","a,%s %s,%d",x,__FILE__,__LINE__);
-#define CLRC emitcode(";XXX clr","c %s,%d",__FILE__,__LINE__);
-
-#define BIT_NUMBER(x) (x & 7)
-#define BIT_REGISTER(x) (x>>3)
+extern struct dbuf_s *codeOutBuf;
+static void saverbank (int, iCode *,bool);
static lineNode *lineHead = NULL;
static lineNode *lineCurr = NULL;
-static unsigned char SLMask[] =
-{0xFF, 0xFE, 0xFC, 0xF8, 0xF0,
- 0xE0, 0xC0, 0x80, 0x00};
-static unsigned char SRMask[] =
-{0xFF, 0x7F, 0x3F, 0x1F, 0x0F,
- 0x07, 0x03, 0x01, 0x00};
-
-#define LSB 0
-#define MSB16 1
-#define MSB24 2
-#define MSB32 3
+#if 0
+static unsigned char SLMask[] = {0xFF ,0xFE, 0xFC, 0xF8, 0xF0,
+0xE0, 0xC0, 0x80, 0x00};
+static unsigned char SRMask[] = {0xFF, 0x7F, 0x3F, 0x1F, 0x0F,
+0x07, 0x03, 0x01, 0x00};
+#endif
+static pBlock *pb;
-#define FUNCTION_LABEL_INC 20
-static int labelOffset = 0;
-static int debug_verbose = 0;
+/*-----------------------------------------------------------------*/
+/* my_powof2(n) - If `n' is an integaer power of 2, then the */
+/* exponent of 2 is returned, otherwise -1 is */
+/* returned. */
+/* note that this is similar to the function `powof2' in SDCCsymt */
+/* if(n == 2^y) */
+/* return y; */
+/* return -1; */
+/*-----------------------------------------------------------------*/
+static int my_powof2 (unsigned long num)
+{
+ if(num) {
+ if( (num & (num-1)) == 0) {
+ int nshifts = -1;
+ while(num) {
+ num>>=1;
+ nshifts++;
+ }
+ return nshifts;
+ }
+ }
+
+ return -1;
+}
+
+void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *result)
+{
+
+ DEBUGpic14_emitcode ("; ","line = %d result %s=%s, size=%d, left %s=%s, size=%d, right %s=%s, size=%d",
+ line_no,
+ ((result) ? AopType(AOP_TYPE(result)) : "-"),
+ ((result) ? aopGet(AOP(result),0,TRUE,FALSE) : "-"),
+ ((result) ? AOP_SIZE(result) : 0),
+ ((left) ? AopType(AOP_TYPE(left)) : "-"),
+ ((left) ? aopGet(AOP(left),0,TRUE,FALSE) : "-"),
+ ((left) ? AOP_SIZE(left) : 0),
+ ((right) ? AopType(AOP_TYPE(right)) : "-"),
+ ((right) ? aopGet(AOP(right),0,FALSE,FALSE) : "-"),
+ ((right) ? AOP_SIZE(right) : 0));
+
+}
+
+void DEBUGpic14_AopTypeSign(int line_no, operand *left, operand *right, operand *result)
+{
+
+ DEBUGpic14_emitcode ("; ","line = %d, signs: result %s=%c, left %s=%c, right %s=%c",
+ line_no,
+ ((result) ? AopType(AOP_TYPE(result)) : "-"),
+ ((result) ? (SPEC_USIGN(operandType(result)) ? 'u' : 's') : '-'),
+ ((left) ? AopType(AOP_TYPE(left)) : "-"),
+ ((left) ? (SPEC_USIGN(operandType(left)) ? 'u' : 's') : '-'),
+ ((right) ? AopType(AOP_TYPE(right)) : "-"),
+ ((right) ? (SPEC_USIGN(operandType(right)) ? 'u' : 's') : '-'));
+
+}
+
+void DEBUGpic14_emitcode (char *inst,char *fmt, ...)
+{
+ va_list ap;
+ char lb[INITIAL_INLINEASM];
+ unsigned char *lbp = (unsigned char *)lb;
+
+ if(!debug_verbose && !options.debug)
+ return;
+
+ 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);
+ } else
+ vsprintf(lb,fmt,ap);
+
+ while (isspace(*lbp)) lbp++;
+
+ if (lbp && *lbp)
+ lineCurr = (lineCurr ?
+ connectLine(lineCurr,newLineNode(lb)) :
+ (lineHead = newLineNode(lb)));
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+
+ addpCode2pBlock(pb,newpCodeCharP(lb));
+
+ va_end(ap);
+}
+
+static void Safe_vsnprintf (char *buf, size_t size, const char *fmt, va_list ap)
+{
+#if defined (HAVE_VSNPRINTF)
+ vsnprintf (buf, size, fmt, ap);
+#elif defined (HAVE_VSPRINTF)
+ vsprintf (buf, size, fmt, ap);
+ if (strlen (buf) >= size)
+ {
+ fprintf (stderr, "Safe_vsnprintf: buffer (size %u) has overflown\n", size);
+ }
+#elif defined (HAVE_SNPRINTF)
+ snprintf (buf, size, "vs(n)printf required");
+#elif defined (HAVE_SRINTF)
+ sprintf (buf, "vs(n)printf required");
+ if (strlen (buf) >= size)
+ {
+ fprintf (stderr, "Safe_vsnprintf: buffer (size %u) has overflown\n", size);
+ }
+#else
+ assert ( !"neither vsnprintf nor vsprintf is present -- unable to proceed" );
+#endif
+}
+void emitpComment (const char *fmt, ...)
+{
+ va_list va;
+ char buffer[4096];
+
+ va_start (va, fmt);
+ if (pb) {
+ Safe_vsnprintf (buffer, 4096, fmt, va);
+ //fprintf (stderr, "%s\n" ,buffer);
+ addpCode2pBlock (pb, newpCodeCharP (buffer));
+#if 0
+ } else {
+ Safe_vsnprintf (buffer, 4096, fmt, va);
+ fprintf (stderr, "No current pBlock -- discarding comment [%s]\n", buffer);
+#endif
+ }
+ va_end (va);
+}
-/*-----------------------------------------------------------------*/
-/* Macros for emitting instructions */
-/*-----------------------------------------------------------------*/
-#define emitSKPC emitcode("btfss","status,c")
-#define emitSKPNC emitcode("btfsc","status,c")
-#define emitSKPZ emitcode("btfss","status,z")
-#define emitSKPNZ emitcode("btfsc","status,z")
+void emitpLabel(int key)
+{
+ addpCode2pBlock(pb,newpCodeLabel(NULL,key+100+labelOffset));
+}
-/*-----------------------------------------------------------------*/
-/* my_powof2(n) - If `n' is an integaer power of 2, then the */
-/* exponent of 2 is returned, otherwise -1 is */
-/* returned. */
-/* note that this is similar to the function `powof2' in SDCCsymt */
-/* if(n == 2^y) */
-/* return y; */
-/* return -1; */
-/*-----------------------------------------------------------------*/
-static int
-my_powof2 (unsigned long num)
+/* gen.h defines a macro emitpcode that should be used to call emitpcode
+ * as this allows for easy debugging (ever asked the question: where was
+ * this instruction geenrated? Here is the answer... */
+void emitpcode_real(PIC_OPCODE poc, pCodeOp *pcop)
{
- if (num)
- {
- if ((num & (num - 1)) == 0)
- {
- int nshifts = -1;
- while (num)
- {
- num >>= 1;
- nshifts++;
- }
- return nshifts;
+ if(pcop)
+ addpCode2pBlock(pb,newpCode(poc,pcop));
+ else {
+ static int has_warned = 0;
+
+ DEBUGpic14_emitcode(";","%s ignoring NULL pcop",__FUNCTION__);
+ if (!has_warned) {
+ has_warned = 1;
+ fprintf( stderr, "WARNING: encountered NULL pcop--this is probably a compiler bug...\n" );
+ }
}
- }
+}
- return -1;
+void emitpcodeNULLop(PIC_OPCODE poc)
+{
+
+ addpCode2pBlock(pb,newpCode(poc,NULL));
+
}
/*-----------------------------------------------------------------*/
-/* emitcode - writes the code into a file : for now it is simple */
+/* pic14_emitcode - writes the code into a file : for now it is simple */
/*-----------------------------------------------------------------*/
-static void
-emitcode (char *inst, char *fmt,...)
+void pic14_emitcode (char *inst,char *fmt, ...)
{
- va_list ap;
- char lb[MAX_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);
- }
- else
- vsprintf (lb, fmt, ap);
-
- 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);
+ 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);
+ } else
+ vsprintf(lb,fmt,ap);
+
+ while (isspace(*lbp)) lbp++;
+
+ if (lbp && *lbp)
+ lineCurr = (lineCurr ?
+ connectLine(lineCurr,newLineNode(lb)) :
+ (lineHead = newLineNode(lb)));
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+ lineCurr->isLabel = (lbp[strlen (lbp) - 1] == ':');
+
+ if(debug_verbose)
+ addpCode2pBlock(pb,newpCodeCharP(lb));
+
+ va_end(ap);
}
-static void
-DEBUGemitcode (char *inst, char *fmt,...)
+/*-----------------------------------------------------------------*/
+/* pic14_emitDebuggerSymbol - associate the current code location */
+/* with a debugger symbol */
+/*-----------------------------------------------------------------*/
+void
+pic14_emitDebuggerSymbol (char * debugSym)
{
- va_list ap;
- char lb[MAX_INLINEASM];
- char *lbp = lb;
-
- if (!debug_verbose)
- return;
-
- 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);
- }
- else
- vsprintf (lb, fmt, ap);
-
- 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);
+ _G.debugLine = 1;
+ pic14_emitcode ("", ";%s ==.", debugSym);
+ _G.debugLine = 0;
}
+#if 0
+/*-----------------------------------------------------------------*/
+/* getFreePtr - returns r0 or r1 whichever is free or can be pushed*/
+/*-----------------------------------------------------------------*/
+static regs *getFreePtr (iCode *ic, asmop **aopp, bool result)
+{
+ bool r0iu = FALSE , r1iu = FALSE;
+ bool r0ou = FALSE , r1ou = FALSE;
+
+ /* the logic: if r0 & r1 used in the instruction
+ then we are in trouble otherwise */
+
+ /* first check if r0 & r1 are used by this
+ instruction, in which case we are in trouble */
+ if ((r0iu = bitVectBitValue(ic->rUsed,R0_IDX)) &&
+ (r1iu = bitVectBitValue(ic->rUsed,R1_IDX)))
+ {
+ goto endOfWorld;
+ }
+
+ r0ou = bitVectBitValue(ic->rMask,R0_IDX);
+ r1ou = bitVectBitValue(ic->rMask,R1_IDX);
+
+ /* if no usage of r0 then return it */
+ if (!r0iu && !r0ou) {
+ ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
+ (*aopp)->type = AOP_R0;
+
+ return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
+ }
+
+ /* if no usage of r1 then return it */
+ if (!r1iu && !r1ou) {
+ ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
+ (*aopp)->type = AOP_R1;
+
+ return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R1_IDX);
+ }
+
+ /* now we know they both have usage */
+ /* if r0 not used in this instruction */
+ if (!r0iu) {
+ /* push it if not already pushed */
+ if (!_G.r0Pushed) {
+ //pic14_emitcode ("push","%s",
+ // pic14_regWithIdx(R0_IDX)->dname);
+ _G.r0Pushed++ ;
+ }
+
+ ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
+ (*aopp)->type = AOP_R0;
+
+ return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
+ }
+
+ /* if r1 not used then */
+
+ if (!r1iu) {
+ /* push it if not already pushed */
+ if (!_G.r1Pushed) {
+ //pic14_emitcode ("push","%s",
+ // pic14_regWithIdx(R1_IDX)->dname);
+ _G.r1Pushed++ ;
+ }
+
+ ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
+ (*aopp)->type = AOP_R1;
+ return pic14_regWithIdx(R1_IDX);
+ }
+
+endOfWorld :
+ /* I said end of world but not quite end of world yet */
+ /* if this is a result then we can push it on the stack*/
+ if (result) {
+ (*aopp)->type = AOP_STK;
+ return NULL;
+ }
+
+ /* other wise this is true end of the world */
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "getFreePtr should never reach here");
+ exit(0);
+}
+#endif
/*-----------------------------------------------------------------*/
-/* getFreePtr - returns r0 or r1 whichever is free or can be pushed */
+/* newAsmop - creates a new asmOp */
/*-----------------------------------------------------------------*/
-static regs *
-getFreePtr (iCode * ic, asmop ** aopp, bool result)
+asmop *newAsmop (short type)
{
- bool r0iu = FALSE, r1iu = FALSE;
- bool r0ou = FALSE, r1ou = FALSE;
-
- /* the logic: if r0 & r1 used in the instruction
- then we are in trouble otherwise */
-
- /* first check if r0 & r1 are used by this
- instruction, in which case we are in trouble */
- if ((r0iu = bitVectBitValue (ic->rUsed, R0_IDX)) &&
- (r1iu = bitVectBitValue (ic->rUsed, R1_IDX)))
- {
- goto endOfWorld;
- }
-
- r0ou = bitVectBitValue (ic->rMask, R0_IDX);
- r1ou = bitVectBitValue (ic->rMask, R1_IDX);
-
- /* if no usage of r0 then return it */
- if (!r0iu && !r0ou)
- {
- ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX);
- (*aopp)->type = AOP_R0;
-
- return (*aopp)->aopu.aop_ptr = pic14_regWithIdx (R0_IDX);
- }
-
- /* if no usage of r1 then return it */
- if (!r1iu && !r1ou)
- {
- ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX);
- (*aopp)->type = AOP_R1;
-
- return (*aopp)->aopu.aop_ptr = pic14_regWithIdx (R1_IDX);
- }
+ asmop *aop;
+
+ aop = Safe_calloc(1,sizeof(asmop));
+ aop->type = type;
+ return aop;
+}
- /* now we know they both have usage */
- /* if r0 not used in this instruction */
- if (!r0iu)
- {
- /* push it if not already pushed */
- if (!_G.r0Pushed)
+static void genSetDPTR(int n)
+{
+ if (!n)
{
- emitcode ("push", "%s",
- pic14_regWithIdx (R0_IDX)->dname);
- _G.r0Pushed++;
+ pic14_emitcode(";", "Select standard DPTR");
+ pic14_emitcode("mov", "dps, #0x00");
}
-
- ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX);
- (*aopp)->type = AOP_R0;
-
- return (*aopp)->aopu.aop_ptr = pic14_regWithIdx (R0_IDX);
- }
-
- /* if r1 not used then */
-
- if (!r1iu)
- {
- /* push it if not already pushed */
- if (!_G.r1Pushed)
+ else
{
- emitcode ("push", "%s",
- pic14_regWithIdx (R1_IDX)->dname);
- _G.r1Pushed++;
+ pic14_emitcode(";", "Select alternate DPTR");
+ pic14_emitcode("mov", "dps, #0x01");
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* resolveIfx - converts an iCode ifx into a form more useful for */
+/* generating code */
+/*-----------------------------------------------------------------*/
+static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
+{
+ if(!resIfx)
+ return;
+
+ // DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ resIfx->condition = 1; /* assume that the ifx is true */
+ resIfx->generated = 0; /* indicate that the ifx has not been used */
+
+ if(!ifx) {
+ resIfx->lbl = NULL; /* this is wrong: newiTempLabel(NULL); / * oops, there is no ifx. so create a label */
+ /*
+ DEBUGpic14_emitcode("; ***","%s %d null ifx creating new label key =%d",
+ __FUNCTION__,__LINE__,resIfx->lbl->key);
+ */
+ } else {
+ if(IC_TRUE(ifx)) {
+ resIfx->lbl = IC_TRUE(ifx);
+ } else {
+ resIfx->lbl = IC_FALSE(ifx);
+ resIfx->condition = 0;
+ }
+ /*
+ if(IC_TRUE(ifx))
+ DEBUGpic14_emitcode("; ***","ifx true is non-null");
+ if(IC_FALSE(ifx))
+ DEBUGpic14_emitcode("; ***","ifx false is non-null");
+ */
}
-
- ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX);
- (*aopp)->type = AOP_R1;
- return pic14_regWithIdx (R1_IDX);
- }
-
-endOfWorld:
- /* I said end of world but not quite end of world yet */
- /* if this is a result then we can push it on the stack */
- if (result)
- {
- (*aopp)->type = AOP_STK;
- return NULL;
- }
-
- piCode (ic, stdout);
- /* other wise this is true end of the world */
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "getFreePtr should never reach here");
- exit (0);
+
+ // DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
+
}
-
/*-----------------------------------------------------------------*/
-/* newAsmop - creates a new asmOp */
+/* pointerCode - returns the code for a pointer type */
/*-----------------------------------------------------------------*/
-static asmop *
-newAsmop (short type)
-{
- asmop *aop;
-
- aop = Safe_calloc (1, sizeof (asmop));
- aop->type = type;
- return aop;
-}
-
-static void
-genSetDPTR (int n)
+#if 0
+static int pointerCode (sym_link *etype)
{
- if (!n)
- {
- emitcode (";", "Select standard DPTR");
- emitcode ("mov", "dps, #0x00");
- }
- else
- {
- emitcode (";", "Select alternate DPTR");
- emitcode ("mov", "dps, #0x01");
- }
+
+ return PTR_TYPE(SPEC_OCLS(etype));
+
}
+#endif
/*-----------------------------------------------------------------*/
-/* pointerCode - returns the code for a pointer type */
-/*-----------------------------------------------------------------*/
-static int
-pointerCode (sym_link * etype)
-{
-
- return PTR_TYPE (SPEC_OCLS (etype));
-
+/* aopForSym - for a true symbol */
+/*-----------------------------------------------------------------*/
+static asmop *aopForSym (iCode *ic,symbol *sym,bool result)
+{
+ asmop *aop;
+ memmap *space= SPEC_OCLS(sym->etype);
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if already has one */
+ if (sym->aop)
+ return sym->aop;
+
+ //DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* if it is in direct space */
+ if (IN_DIRSPACE(space)) {
+ sym->aop = aop = newAsmop (AOP_DIR);
+ aop->aopu.aop_dir = sym->rname ;
+ aop->size = getSize(sym->type);
+ DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
+ return aop;
+ }
+
+ /* special case for a function */
+ if (IS_FUNC(sym->type)) {
+
+ sym->aop = aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
+ PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+ PCOI(aop->aopu.pcop)->_function = 1;
+ PCOI(aop->aopu.pcop)->index = 0;
+ aop->size = FPTRSIZE;
+ /*
+ sym->aop = aop = newAsmop(AOP_IMMD);
+ aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
+ strcpy(aop->aopu.aop_immd,sym->rname);
+ aop->size = FPTRSIZE;
+ */
+ DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
+ return aop;
+ }
+
+ if (IS_ARRAY(sym->type)) {
+ sym->aop = aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
+ PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+ PCOI(aop->aopu.pcop)->_function = 0;
+ PCOI(aop->aopu.pcop)->index = 0;
+ aop->size = getSize(sym->etype) * DCL_ELEM(sym->type);
+
+ DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
+ return aop;
+ }
+
+ /* only remaining is far space */
+ /* in which case DPTR gets the address */
+ sym->aop = aop = newAsmop(AOP_PCODE);
+
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,0);
+ PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+ PCOI(aop->aopu.pcop)->index = 0;
+
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+
+ allocDirReg (IC_LEFT(ic));
+
+ aop->size = FPTRSIZE;
+ /*
+ DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
+ sym->aop = aop = newAsmop(AOP_DPTR);
+ pic14_emitcode ("mov","dptr,#%s", sym->rname);
+ aop->size = getSize(sym->type);
+
+ DEBUGpic14_emitcode(";","%d size = %d",__LINE__,aop->size);
+ */
+
+ /* if it is in code space */
+ if (IN_CODESPACE(space))
+ aop->code = 1;
+
+ return aop;
+}
+
+/*-----------------------------------------------------------------*/
+/* aopForRemat - rematerialzes an object */
+/*-----------------------------------------------------------------*/
+static asmop *aopForRemat (operand *op) // x symbol *sym)
+{
+ symbol *sym = OP_SYMBOL(op);
+ iCode *ic = NULL;
+ asmop *aop = newAsmop(AOP_PCODE);
+ int val = 0;
+ int offset = 0;
+
+ ic = sym->rematiCode;
+
+ DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
+ if(IS_OP_POINTER(op)) {
+ DEBUGpic14_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
+ }
+ for (;;) {
+ if (ic->op == '+') {
+ val += (int) operandLitValue(IC_RIGHT(ic));
+ } else if (ic->op == '-') {
+ val -= (int) operandLitValue(IC_RIGHT(ic));
+ } else
+ break;
+
+ ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
+ }
+
+ offset = OP_SYMBOL(IC_LEFT(ic))->offset;
+ aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val,0);
+ PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
+ PCOI(aop->aopu.pcop)->index = val;
+
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
+ val, IS_PTR_CONST(operandType(op)));
+
+ // DEBUGpic14_emitcode(";","aop type %s",AopType(AOP_TYPE(IC_LEFT(ic))));
+
+ allocDirReg (IC_LEFT(ic));
+
+ return aop;
+}
+
+int aopIdx (asmop *aop, int offset)
+{
+ if(!aop)
+ return -1;
+
+ if(aop->type != AOP_REG)
+ return -2;
+
+ return aop->aopu.aop_reg[offset]->rIdx;
+
+}
+/*-----------------------------------------------------------------*/
+/* regsInCommon - two operands have some registers in common */
+/*-----------------------------------------------------------------*/
+static bool regsInCommon (operand *op1, operand *op2)
+{
+ symbol *sym1, *sym2;
+ int i;
+
+ /* if they have registers in common */
+ if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
+ return FALSE ;
+
+ sym1 = OP_SYMBOL(op1);
+ sym2 = OP_SYMBOL(op2);
+
+ if (sym1->nRegs == 0 || sym2->nRegs == 0)
+ return FALSE ;
+
+ for (i = 0 ; i < sym1->nRegs ; i++) {
+ int j;
+ if (!sym1->regs[i])
+ continue ;
+
+ for (j = 0 ; j < sym2->nRegs ;j++ ) {
+ if (!sym2->regs[j])
+ continue ;
+
+ if (sym2->regs[j] == sym1->regs[i])
+ return TRUE ;
+ }
+ }
+
+ return FALSE ;
+}
+
+/*-----------------------------------------------------------------*/
+/* operandsEqu - equivalent */
+/*-----------------------------------------------------------------*/
+static bool operandsEqu ( operand *op1, operand *op2)
+{
+ symbol *sym1, *sym2;
+
+ /* if they not symbols */
+ if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
+ return FALSE;
+
+ sym1 = OP_SYMBOL(op1);
+ sym2 = OP_SYMBOL(op2);
+
+ /* if both are itemps & one is spilt
+ and the other is not then false */
+ if (IS_ITEMP(op1) && IS_ITEMP(op2) &&
+ sym1->isspilt != sym2->isspilt )
+ return FALSE ;
+
+ /* if they are the same */
+ if (sym1 == sym2)
+ return TRUE ;
+
+ if (sym1->rname[0] && sym2->rname[0]
+ && strcmp (sym1->rname, sym2->rname) == 0)
+ return TRUE;
+
+
+ /* if left is a tmp & right is not */
+ if (IS_ITEMP(op1) &&
+ !IS_ITEMP(op2) &&
+ sym1->isspilt &&
+ (sym1->usl.spillLoc == sym2))
+ return TRUE;
+
+ if (IS_ITEMP(op2) &&
+ !IS_ITEMP(op1) &&
+ sym2->isspilt &&
+ sym1->level > 0 &&
+ (sym2->usl.spillLoc == sym1))
+ return TRUE ;
+
+ return FALSE ;
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_sameRegs - two asmops have the same registers */
+/*-----------------------------------------------------------------*/
+bool pic14_sameRegs (asmop *aop1, asmop *aop2 )
+{
+ int i;
+
+ if (aop1 == aop2)
+ return TRUE ;
+
+ if (aop1->type != AOP_REG ||
+ aop2->type != AOP_REG )
+ return FALSE ;
+
+ if (aop1->size != aop2->size )
+ return FALSE ;
+
+ for (i = 0 ; i < aop1->size ; i++ )
+ if (aop1->aopu.aop_reg[i] !=
+ aop2->aopu.aop_reg[i] )
+ return FALSE ;
+
+ return TRUE ;
}
/*-----------------------------------------------------------------*/
-/* aopForSym - for a true symbol */
+/* aopOp - allocates an asmop for an operand : */
/*-----------------------------------------------------------------*/
-static asmop *
-aopForSym (iCode * ic, symbol * sym, bool result)
-{
- asmop *aop;
- memmap *space = SPEC_OCLS (sym->etype);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if already has one */
- if (sym->aop)
- return sym->aop;
-
- /* assign depending on the storage class */
- /* if it is on the stack or indirectly addressable */
- /* space we need to assign either r0 or r1 to it */
- if ((sym->onStack && !options.stack10bit) || sym->iaccess)
- {
- sym->aop = aop = newAsmop (0);
- aop->aopu.aop_ptr = getFreePtr (ic, &aop, result);
- aop->size = getSize (sym->type);
+void aopOp (operand *op, iCode *ic, bool result)
+{
+ asmop *aop;
+ symbol *sym;
+ int i;
+
+ if (!op)
+ return ;
+
+ /* if this a literal */
+ if (IS_OP_LITERAL(op)) {
+ op->aop = aop = newAsmop(AOP_LIT);
+ aop->aopu.aop_lit = op->operand.valOperand;
+ aop->size = getSize(operandType(op));
+ return;
+ }
+
+ {
+ sym_link *type = operandType(op);
+ if(IS_PTR_CONST(type))
+ DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
+ }
+
+ /* if already has a asmop then continue */
+ if (op->aop)
+ return ;
+
+ /* if the underlying symbol has a aop */
+ if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ op->aop = OP_SYMBOL(op)->aop;
+ return;
+ }
+
+ /* if this is a true symbol */
+ if (IS_TRUE_SYMOP(op)) {
+ //DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
+ op->aop = aopForSym(ic,OP_SYMBOL(op),result);
+ return ;
+ }
+
+ /* this is a temporary : this has
+ only four choices :
+ a) register
+ b) spillocation
+ c) rematerialize
+ d) conditional
+ e) can be a return use only */
+
+ sym = OP_SYMBOL(op);
+
+
+ /* if the type is a conditional */
+ if (sym->regType == REG_CND) {
+ aop = op->aop = sym->aop = newAsmop(AOP_CRY);
+ aop->size = 0;
+ return;
+ }
+
+ /* if it is spilt then two situations
+ a) is rematerialize
+ b) has a spill location */
+ if (sym->isspilt || sym->nRegs == 0) {
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* rematerialize it NOW */
+ if (sym->remat) {
+
+ sym->aop = op->aop = aop = aopForRemat (op);
+ aop->size = getSize(sym->type);
+ //DEBUGpic14_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
+ return;
+ }
+
+#if 0
+ /* WREG is not usable as an ordinary operand with PIC architecture,
+ * one might introduce a scratch register that can be used to make
+ * WREG accesible as an operand... disable WREG for now */
+ if (sym->accuse) {
+ int i;
+ aop = op->aop = sym->aop = newAsmop(AOP_ACC);
+ aop->size = getSize(sym->type);
+ for ( i = 0 ; i < 2 ; i++ )
+ aop->aopu.aop_str[i] = accUse[i];
+ DEBUGpic14_emitcode(";","%d size=%d",__LINE__,aop->size);
+ return;
+ }
+#endif
+
+ if (sym->ruonly ) {
+ if(sym->isptr) { // && sym->uptr
+ aop = op->aop = sym->aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = newpCodeOp(NULL,PO_GPR_POINTER); //popCopyReg(&pc_fsr);
+
+ //PCOI(aop->aopu.pcop)->_const = 0;
+ //PCOI(aop->aopu.pcop)->index = 0;
+ /*
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+ */
+ //allocDirReg (IC_LEFT(ic));
+
+ aop->size = getSize(sym->type);
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return;
+
+ } else {
+
+ unsigned i;
+
+ aop = op->aop = sym->aop = newAsmop(AOP_STR);
+ aop->size = getSize(sym->type);
+ for ( i = 0 ; i < fReturnSizePic ; i++ )
+ aop->aopu.aop_str[i] = fReturn[i];
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return;
+ }
+ }
+
+ /* else spill location */
+ if (sym->usl.spillLoc)
+ {
+ asmop *oldAsmOp = NULL;
- /* now assign the address of the variable to
- the pointer register */
- if (aop->type != AOP_STK)
+ if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
+ {
+ /* force a new aop if sizes differ */
+ oldAsmOp = sym->usl.spillLoc->aop;
+ sym->usl.spillLoc->aop = NULL;
+ }
+ DEBUGpic14_emitcode(";","%s %d %s sym->rname = %s, offset %d",
+ __FUNCTION__,__LINE__,
+ sym->usl.spillLoc->rname,
+ sym->rname, sym->usl.spillLoc->offset);
+
+ sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
+ if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
+ {
+ /* Don't reuse the new aop, go with the last one */
+ sym->usl.spillLoc->aop = oldAsmOp;
+ }
+ //aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
+ aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
+ getSize(sym->type),
+ sym->usl.spillLoc->offset);
+ aop->size = getSize(sym->type);
+
+ return;
+ }
+ }
+
{
-
- if (sym->onStack)
- {
- 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);
- emitcode ("mov", "%s,a",
- aop->aopu.aop_ptr->name);
-
- if (_G.accInUse)
- emitcode ("pop", "acc");
- }
- else
- emitcode ("mov", "%s,#%s",
- aop->aopu.aop_ptr->name,
- sym->rname);
- aop->paged = space->paged;
+ sym_link *type = operandType(op);
+ if(IS_PTR_CONST(type))
+ DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
}
- else
- aop->aopu.aop_stk = sym->stack;
- return aop;
- }
-
- if (sym->onStack && options.stack10bit)
- {
- /* It's on the 10 bit stack, which is located in
- * far data space.
- */
-
- //DEBUGemitcode(";","%d",__LINE__);
-
- 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);
-
- genSetDPTR (1);
- emitcode ("mov", "dpx1,#0x40");
- emitcode ("mov", "dph1,#0x00");
- emitcode ("mov", "dpl1, a");
- genSetDPTR (0);
-
- if (_G.accInUse)
- emitcode ("pop", "acc");
-
- sym->aop = aop = newAsmop (AOP_DPTR2);
- aop->size = getSize (sym->type);
- return aop;
- }
-
- //DEBUGemitcode(";","%d",__LINE__);
- /* if in bit space */
- if (IN_BITSPACE (space))
- {
- sym->aop = aop = newAsmop (AOP_CRY);
- aop->aopu.aop_dir = sym->rname;
- aop->size = getSize (sym->type);
- DEBUGemitcode (";", "%d sym->rname = %s, size = %d", __LINE__, sym->rname, aop->size);
- return aop;
- }
- /* if it is in direct space */
- if (IN_DIRSPACE (space))
- {
- sym->aop = aop = newAsmop (AOP_DIR);
- aop->aopu.aop_dir = sym->rname;
- aop->size = getSize (sym->type);
- DEBUGemitcode (";", "%d sym->rname = %s, size = %d", __LINE__, sym->rname, aop->size);
- return aop;
- }
-
- /* special case for a function */
- if (IS_FUNC (sym->type))
- {
- sym->aop = aop = newAsmop (AOP_IMMD);
- aop->aopu.aop_immd = Safe_calloc (1, strlen (sym->rname) + 1);
- strcpy (aop->aopu.aop_immd, sym->rname);
- aop->size = FPTRSIZE;
- return aop;
- }
+
+ /* must be in a register */
+ DEBUGpic14_emitcode(";","%d register type nRegs=%d",__LINE__,sym->nRegs);
+ sym->aop = op->aop = aop = newAsmop(AOP_REG);
+ aop->size = sym->nRegs;
+ for ( i = 0 ; i < sym->nRegs ;i++)
+ aop->aopu.aop_reg[i] = sym->regs[i];
+}
+/*-----------------------------------------------------------------*/
+/* freeAsmop - free up the asmop given to an operand */
+/*----------------------------------------------------------------*/
+void freeAsmop (operand *op, asmop *aaop, iCode *ic, bool pop)
+{
+ asmop *aop ;
+
+ if (!op)
+ aop = aaop;
+ else
+ aop = op->aop;
+
+ if (!aop)
+ return ;
+
+ if (aop->freed)
+ goto dealloc;
+
+ aop->freed = 1;
+
+ /* depending on the asmop type only three cases need work AOP_RO
+ , AOP_R1 && AOP_STK */
+#if 0
+ switch (aop->type) {
+ case AOP_R0 :
+ if (_G.r0Pushed ) {
+ if (pop) {
+ pic14_emitcode ("pop","ar0");
+ _G.r0Pushed--;
+ }
+ }
+ bitVectUnSetBit(ic->rUsed,R0_IDX);
+ break;
+
+ case AOP_R1 :
+ if (_G.r1Pushed ) {
+ if (pop) {
+ pic14_emitcode ("pop","ar1");
+ _G.r1Pushed--;
+ }
+ }
+ bitVectUnSetBit(ic->rUsed,R1_IDX);
+ break;
+
+ case AOP_STK :
+ {
+ int sz = aop->size;
+ int stk = aop->aopu.aop_stk + aop->size;
+ bitVectUnSetBit(ic->rUsed,R0_IDX);
+ bitVectUnSetBit(ic->rUsed,R1_IDX);
+
+ getFreePtr(ic,&aop,FALSE);
+
+ if (options.stack10bit)
+ {
+ /* I'm not sure what to do here yet... */
+ /* #STUB */
+ fprintf(stderr,
+ "*** Warning: probably generating bad code for "
+ "10 bit stack mode.\n");
+ }
+
+ if (stk) {
+ pic14_emitcode ("mov","a,_bp");
+ pic14_emitcode ("add","a,#0x%02x",((char)stk) & 0xff);
+ pic14_emitcode ("mov","%s,a",aop->aopu.aop_ptr->name);
+ } else {
+ pic14_emitcode ("mov","%s,_bp",aop->aopu.aop_ptr->name);
+ }
+
+ while (sz--) {
+ pic14_emitcode("pop","acc");
+ pic14_emitcode("mov","@%s,a",aop->aopu.aop_ptr->name);
+ if (!sz) break;
+ pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
+ }
+ op->aop = aop;
+ freeAsmop(op,NULL,ic,TRUE);
+ if (_G.r0Pushed) {
+ pic14_emitcode("pop","ar0");
+ _G.r0Pushed--;
+ }
+
+ if (_G.r1Pushed) {
+ pic14_emitcode("pop","ar1");
+ _G.r1Pushed--;
+ }
+ }
+ }
+#endif
+
+dealloc:
+ /* all other cases just dealloc */
+ if (op ) {
+ op->aop = NULL;
+ if (IS_SYMOP(op)) {
+ OP_SYMBOL(op)->aop = NULL;
+ /* if the symbol has a spill */
+ if (SPIL_LOC(op))
+ SPIL_LOC(op)->aop = NULL;
+ }
+ }
+}
- /* only remaining is far space */
- /* in which case DPTR gets the address */
- sym->aop = aop = newAsmop (AOP_DPTR);
- emitcode ("mov", "dptr,#%s", sym->rname);
- aop->size = getSize (sym->type);
+/*-----------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop */
+/*-----------------------------------------------------------------*/
+char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
+{
+ char *s = buffer ;
+ char *rs;
+
+ //DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* offset is greater than
+ size then zero */
+ assert(aop);
+ if (offset > (aop->size - 1) &&
+ aop->type != AOP_LIT)
+ return zero;
+
+ /* depending on type */
+ switch (aop->type) {
+
+ case AOP_R0:
+ case AOP_R1:
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* if we need to increment it */
+ while (offset > aop->coff) {
+ pic14_emitcode ("inc","%s",aop->aopu.aop_ptr->name);
+ aop->coff++;
+ }
+
+ while (offset < aop->coff) {
+ pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
+ aop->coff--;
+ }
+
+ aop->coff = offset ;
+ if (aop->paged) {
+ pic14_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;
+
+ case AOP_DPTR:
+ case AOP_DPTR2:
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(1);
+ }
+
+ while (offset > aop->coff) {
+ pic14_emitcode ("inc","dptr");
+ aop->coff++;
+ }
+
+ while (offset < aop->coff) {
+ pic14_emitcode("lcall","__decdptr");
+ aop->coff--;
+ }
+
+ aop->coff = offset;
+ if (aop->code) {
+ pic14_emitcode("clr","a");
+ pic14_emitcode("movc","a,@a+dptr");
+ }
+ else {
+ pic14_emitcode("movx","a,@dptr");
+ }
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(0);
+ }
+
+ return (dname ? "acc" : "a");
+
+
+ case AOP_IMMD:
+ if (bit16)
+ sprintf (s,"%s",aop->aopu.aop_immd);
+ else
+ if (offset)
+ sprintf(s,"(%s >> %d)",
+ aop->aopu.aop_immd,
+ offset*8);
+ else
+ sprintf(s,"%s",
+ aop->aopu.aop_immd);
+ DEBUGpic14_emitcode(";","%d immd %s",__LINE__,s);
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ case AOP_DIR:
+ if (offset) {
+ sprintf(s,"(%s + %d)",
+ aop->aopu.aop_dir,
+ offset);
+ DEBUGpic14_emitcode(";","oops AOP_DIR did this %s\n",s);
+ } else
+ sprintf(s,"%s",aop->aopu.aop_dir);
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ case AOP_REG:
+ //if (dname)
+ // return aop->aopu.aop_reg[offset]->dname;
+ //else
+ return aop->aopu.aop_reg[offset]->name;
+
+ case AOP_CRY:
+ //pic14_emitcode(";","%d",__LINE__);
+ return aop->aopu.aop_dir;
+
+ case AOP_ACC:
+ DEBUGpic14_emitcode(";Warning -pic port ignoring get(AOP_ACC)","%d",__LINE__);
+ return "AOP_accumulator_bug";
+
+ case AOP_LIT:
+ sprintf(s, "0x%02x", pic14aopLiteral (aop->aopu.aop_lit, offset));
+ rs = Safe_strdup(s);
+ return rs;
+
+ case AOP_STR:
+ aop->coff = offset ;
+ if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
+ dname)
+ return "acc";
+ DEBUGpic14_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
+
+ return aop->aopu.aop_str[offset];
+
+ case AOP_PCODE:
+ {
+ pCodeOp *pcop = aop->aopu.pcop;
+ DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
+ if(pcop->name) {
+ if (pcop->type == PO_IMMEDIATE) {
+ offset += PCOI(pcop)->index;
+ }
+ if (offset) {
+ DEBUGpic14_emitcode(";","%s offset %d",pcop->name,offset);
+ sprintf(s,"(%s+%d)", pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%s",pcop->name);
+ sprintf(s,"%s", pcop->name);
+ }
+ } else
+ sprintf(s,"0x%02x", PCOI(aop->aopu.pcop)->offset);
+
+ }
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ }
+
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopget got unsupported aop->type");
+ exit(0);
+}
- DEBUGemitcode (";", "%d size = %d", __LINE__, aop->size);
- /* if it is in code space */
- if (IN_CODESPACE (space))
- aop->code = 1;
- return aop;
+/*-----------------------------------------------------------------*/
+/* popGetTempReg - create a new temporary pCodeOp */
+/*-----------------------------------------------------------------*/
+pCodeOp *popGetTempReg(void)
+{
+
+ pCodeOp *pcop;
+
+ pcop = newpCodeOp(NULL, PO_GPR_TEMP);
+ if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
+ PCOR(pcop)->r->wasUsed=1;
+ PCOR(pcop)->r->isFree=0;
+ }
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
-/* aopForRemat - rematerialzes an object */
+/* popReleaseTempReg - create a new temporary pCodeOp */
/*-----------------------------------------------------------------*/
-static asmop *
-aopForRemat (symbol * sym)
+void popReleaseTempReg(pCodeOp *pcop)
{
- iCode *ic = sym->rematiCode;
- asmop *aop = newAsmop (AOP_IMMD);
- int val = 0;
- DEBUGemitcode (";", "%s %d", __FUNCTION__, __LINE__);
- for (;;)
- {
- if (ic->op == '+')
- val += operandLitValue (IC_RIGHT (ic));
- else if (ic->op == '-')
- val -= operandLitValue (IC_RIGHT (ic));
- else
- break;
-
- ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
- }
-
- 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);
-
- //DEBUGemitcode(";","%s",buffer);
- aop->aopu.aop_immd = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd, buffer);
- return aop;
+
+ if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r)
+ PCOR(pcop)->r->isFree = 1;
+
}
-
/*-----------------------------------------------------------------*/
-/* regsInCommon - two operands have some registers in common */
+/* popGetLabel - create a new pCodeOp of type PO_LABEL */
/*-----------------------------------------------------------------*/
-static bool
-regsInCommon (operand * op1, operand * op2)
+pCodeOp *popGetLabel(unsigned int key)
{
- symbol *sym1, *sym2;
- int i;
-
- /* if they have registers in common */
- if (!IS_SYMOP (op1) || !IS_SYMOP (op2))
- return FALSE;
-
- sym1 = OP_SYMBOL (op1);
- sym2 = OP_SYMBOL (op2);
-
- if (sym1->nRegs == 0 || sym2->nRegs == 0)
- return FALSE;
-
- for (i = 0; i < sym1->nRegs; i++)
- {
- int j;
- if (!sym1->regs[i])
- continue;
-
- for (j = 0; j < sym2->nRegs; j++)
- {
- if (!sym2->regs[j])
- continue;
-
- if (sym2->regs[j] == sym1->regs[i])
- return TRUE;
- }
- }
+
+ DEBUGpic14_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, labelOffset);
+
+ if(key>(unsigned int)max_key)
+ max_key = key;
+
+ return newpCodeOpLabel(NULL,key+100+labelOffset);
+}
- return FALSE;
+/*-------------------------------------------------------------------*/
+/* popGetHighLabel - create a new pCodeOp of type PO_LABEL with offset=1 */
+/*-------------------------------------------------------------------*/
+pCodeOp *popGetHighLabel(unsigned int key)
+{
+ pCodeOp *pcop;
+ pcop = popGetLabel(key);
+ PCOLAB(pcop)->offset = 1;
+ return pcop;
}
/*-----------------------------------------------------------------*/
-/* operandsEqu - equivalent */
+/* popGetLit - asm operator to pcode operator conversion */
/*-----------------------------------------------------------------*/
-static bool
-operandsEqu (operand * op1, operand * op2)
+pCodeOp *popGetLit(unsigned int lit)
{
- symbol *sym1, *sym2;
-
- /* if they not symbols */
- if (!IS_SYMOP (op1) || !IS_SYMOP (op2))
- return FALSE;
-
- sym1 = OP_SYMBOL (op1);
- sym2 = OP_SYMBOL (op2);
-
- /* if both are itemps & one is spilt
- and the other is not then false */
- if (IS_ITEMP (op1) && IS_ITEMP (op2) &&
- sym1->isspilt != sym2->isspilt)
- return FALSE;
-
- /* if they are the same */
- if (sym1 == sym2)
- return TRUE;
-
- if (strcmp (sym1->rname, sym2->rname) == 0)
- return TRUE;
-
-
- /* if left is a tmp & right is not */
- if (IS_ITEMP (op1) &&
- !IS_ITEMP (op2) &&
- sym1->isspilt &&
- (sym1->usl.spillLoc == sym2))
- return TRUE;
-
- if (IS_ITEMP (op2) &&
- !IS_ITEMP (op1) &&
- sym2->isspilt &&
- sym1->level > 0 &&
- (sym2->usl.spillLoc == sym1))
- return TRUE;
-
- return FALSE;
+
+ return newpCodeOpLit((unsigned char)lit);
}
/*-----------------------------------------------------------------*/
-/* sameRegs - two asmops have the same registers */
+/* popGetImmd - asm operator to pcode immediate conversion */
/*-----------------------------------------------------------------*/
-static bool
-sameRegs (asmop * aop1, asmop * aop2)
+pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func)
{
- int i;
-
- if (aop1 == aop2)
- return TRUE;
-
- if (aop1->type != AOP_REG ||
- aop2->type != AOP_REG)
- return FALSE;
-
- if (aop1->size != aop2->size)
- return FALSE;
-
- for (i = 0; i < aop1->size; i++)
- if (aop1->aopu.aop_reg[i] !=
- aop2->aopu.aop_reg[i])
- return FALSE;
-
- return TRUE;
+
+ return newpCodeOpImmd(name, offset,index, 0, is_func);
}
+extern set *externs;
+
/*-----------------------------------------------------------------*/
-/* aopOp - allocates an asmop for an operand : */
+/* popGetWithString - asm operator to pcode operator conversion */
/*-----------------------------------------------------------------*/
-static void
-aopOp (operand * op, iCode * ic, bool result)
+pCodeOp *popGetWithString(char *str, int isExtern)
{
- asmop *aop;
- symbol *sym;
- int i;
+ pCodeOp *pcop;
+
+
+ if(!str) {
+ fprintf(stderr,"NULL string %s %d\n",__FILE__,__LINE__);
+ exit (1);
+ }
+
+ pcop = newpCodeOp(str,PO_STR);
+ PCOS(pcop)->isPublic = isExtern ? 1 : 0;
- if (!op)
- return;
-
- DEBUGemitcode (";", "%d", __LINE__);
- /* if this a literal */
- if (IS_OP_LITERAL (op))
- {
- DEBUGemitcode (";", "%d", __LINE__);
- op->aop = aop = newAsmop (AOP_LIT);
- aop->aopu.aop_lit = op->operand.valOperand;
- aop->size = getSize (operandType (op));
- return;
- }
-
- /* if already has a asmop then continue */
- if (op->aop)
- return;
-
- /* if the underlying symbol has a aop */
- if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
- {
- DEBUGemitcode (";", "%d", __LINE__);
- op->aop = OP_SYMBOL (op)->aop;
- return;
- }
-
- /* if this is a true symbol */
- if (IS_TRUE_SYMOP (op))
- {
- DEBUGemitcode (";", "%d", __LINE__);
- op->aop = aopForSym (ic, OP_SYMBOL (op), result);
- return;
- }
-
- /* this is a temporary : this has
- only four choices :
- a) register
- b) spillocation
- c) rematerialize
- d) conditional
- e) can be a return use only */
-
- sym = OP_SYMBOL (op);
+ return pcop;
+}
+pCodeOp *popGetExternal (char *str)
+{
+ pCodeOp *pcop = popGetWithString (str, 1);
+
+ if (str) {
+ symbol *sym;
+ bool found = 0;
- /* if the type is a conditional */
- if (sym->regType == REG_CND)
- {
- DEBUGemitcode (";", "%d", __LINE__);
- aop = op->aop = sym->aop = newAsmop (AOP_CRY);
- aop->size = 0;
- return;
- }
+ for (sym = setFirstItem (externs); !found && sym; sym = setNextItem (externs))
+ {
+ if (!strcmp (str, sym->rname))
+ found = 1;
+ }
+
+ if (!found)
+ {
+ sym = newSymbol(str, 0);
+ strncpy(sym->rname, str, SDCC_NAME_MAX);
+ addSet (&externs, sym);
+ } // if
+ }
+ return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popRegFromString - */
+/*-----------------------------------------------------------------*/
+pCodeOp *popRegFromString(char *str, int size, int offset)
+{
+
+ pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop->type = PO_DIR;
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+
+ if(!str)
+ str = "BAD_STRING";
+
+ pcop->name = Safe_calloc(1,strlen(str)+1);
+ strcpy(pcop->name,str);
+
+ //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+ PCOR(pcop)->r = dirregWithName(pcop->name);
+ if(PCOR(pcop)->r == NULL) {
+ //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+ PCOR(pcop)->r = allocRegByName (pcop->name,size);
+ DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ }
+ PCOR(pcop)->instance = offset;
+
+ return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+pCodeOp *popRegFromIdx(int rIdx)
+{
+ pCodeOp *pcop;
+
+ DEBUGpic14_emitcode ("; ***","%s,%d , rIdx=0x%x",
+ __FUNCTION__,__LINE__,rIdx);
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = typeRegWithIdx(rIdx,REG_STK,1);
+ PCOR(pcop)->r->isFree = 0;
+ PCOR(pcop)->r->wasUsed = 1;
+
+ pcop->type = PCOR(pcop)->r->pc_type;
+
+
+ return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popGet - asm operator to pcode operator conversion */
+/*-----------------------------------------------------------------*/
+pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
+{
+ //char *s = buffer ;
+ //char *rs;
+
+ pCodeOp *pcop;
+
+ //DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* offset is greater than
+ size then zero */
+
+ assert (aop);
+
+
+ /* XXX: still needed for BIT operands (AOP_CRY) */
+ if (offset > (aop->size - 1) &&
+ aop->type != AOP_LIT &&
+ aop->type != AOP_PCODE)
+ {
+ printf( "%s: (offset[%d] > AOP_SIZE(op)[%d]-1) && AOP_TYPE(op) != AOP_LIT)\n", __FUNCTION__, offset, aop->size);
+ return NULL; //zero;
+ }
+
+ /* depending on type */
+ switch (aop->type) {
+
+ case AOP_R0:
+ case AOP_R1:
+ case AOP_DPTR:
+ case AOP_DPTR2:
+ case AOP_ACC:
+ DEBUGpic14_emitcode(";8051 legacy","%d type = %s",__LINE__,AopType(aop->type));
+ return NULL;
+
+ case AOP_IMMD:
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return popGetImmd(aop->aopu.aop_immd,offset,0,0);
+
+ case AOP_DIR:
+ return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
+#if 0
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop->type = PO_DIR;
+
+ pcop->name = Safe_calloc(1,strlen(aop->aopu.aop_dir)+1);
+ strcpy(pcop->name,aop->aopu.aop_dir);
+ PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
+ if(PCOR(pcop)->r == NULL) {
+ //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+ PCOR(pcop)->r = allocRegByName (aop->aopu.aop_dir,aop->size);
+ DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ }
+ PCOR(pcop)->instance = offset;
+
+ return pcop;
+#endif
+
+ case AOP_REG:
+ {
+ int rIdx;
+ assert (offset < aop->size);
+ rIdx = aop->aopu.aop_reg[offset]->rIdx;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+ PCOR(pcop)->r->wasUsed=1;
+ PCOR(pcop)->r->isFree=0;
+
+ PCOR(pcop)->instance = offset;
+ pcop->type = PCOR(pcop)->r->pc_type;
+ //rs = aop->aopu.aop_reg[offset]->name;
+ DEBUGpic14_emitcode(";","%d rIdx = r0x%X ",__LINE__,rIdx);
+ return pcop;
+ }
+
+ case AOP_CRY:
+ pcop = newpCodeOpBit(aop->aopu.aop_dir,-1,1);
+ PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
+ //if(PCOR(pcop)->r == NULL)
+ //fprintf(stderr,"%d - couldn't find %s in allocated registers\n",__LINE__,aop->aopu.aop_dir);
+ return pcop;
+
+ case AOP_LIT:
+ return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
+
+ case AOP_STR:
+ DEBUGpic14_emitcode(";","%d %s",__LINE__,aop->aopu.aop_str[offset]);
+ return newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
+ /*
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcop)->r = allocRegByName(aop->aopu.aop_str[offset]);
+ PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
+ pcop->type = PCOR(pcop)->r->pc_type;
+ pcop->name = PCOR(pcop)->r->name;
+
+ return pcop;
+ */
+
+ case AOP_PCODE:
+ pcop = NULL;
+ DEBUGpic14_emitcode(";","popGet AOP_PCODE (%s + %i) %d %s",pCodeOpType(aop->aopu.pcop), offset,
+ __LINE__,
+ ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"));
+ //emitpComment ("popGet; name %s, offset: %i, pcop-type: %s\n", aop->aopu.pcop->name, offset, pCodeOpType (aop->aopu.pcop));
+ switch (aop->aopu.pcop->type)
+ {
+ case PO_IMMEDIATE:
+ pcop = pCodeOpCopy (aop->aopu.pcop);
+ /* usually we want to access the memory at "<symbol> + offset" (using ->index),
+ * but sometimes we want to access the high byte of the symbol's address (using ->offset) */
+ PCOI(pcop)->index += offset;
+ //PCOI(pcop)->offset = 0;
+ break;
+ case PO_DIR:
+ pcop = pCodeOpCopy (aop->aopu.pcop);
+ PCOR(pcop)->instance = offset;
+ break;
+ default:
+ assert ( !"unhandled pCode type" );
+ break;
+ } // switch
+ return pcop;
+ }
+
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "popGet got unsupported aop->type");
+ exit(0);
+}
- /* if it is spilt then two situations
- a) is rematerialize
- b) has a spill location */
- if (sym->isspilt || sym->nRegs == 0)
- {
+/*-----------------------------------------------------------------*/
+/* popGetAddr - access the low/high word of a symbol (immediate) */
+/* (for non-PO_IMMEDIATEs this is the same as popGet) */
+/*-----------------------------------------------------------------*/
+pCodeOp *popGetAddr (asmop *aop, int offset, int index)
+{
+ if (aop->type == AOP_PCODE && aop->aopu.pcop->type == PO_IMMEDIATE)
+ {
+ pCodeOp *pcop = aop->aopu.pcop;
+ assert (offset <= GPTRSIZE);
+
+ /* special case: index >= 2 should return GPOINTER-style values */
+ if (offset == 2)
+ {
+ pcop = popGetLit (aop->code ? GPTRTAG_CODE : GPTRTAG_DATA);
+ return pcop;
+ }
+
+ pcop = pCodeOpCopy (pcop);
+ /* usually we want to access the memory at "<symbol> + offset" (using ->index),
+ * but sometimes we want to access the high byte of the symbol's address (using ->offset) */
+ PCOI(pcop)->offset += offset;
+ PCOI(pcop)->index += index;
+ //fprintf (stderr, "is PO_IMMEDIATE: %s+o%d+i%d (new o%d,i%d)\n", pcop->name,PCOI(pcop)->offset,PCOI(pcop)->index, offset, index);
+ return pcop;
+ } else {
+ return popGet (aop, offset + index);
+ }
+}
- DEBUGemitcode (";", "%d", __LINE__);
- /* rematerialize it NOW */
- if (sym->remat)
- {
- sym->aop = op->aop = aop =
- aopForRemat (sym);
- aop->size = getSize (sym->type);
- DEBUGemitcode (";", "%d", __LINE__);
- return;
+/*-----------------------------------------------------------------*/
+/* aopPut - puts a string for a aop */
+/*-----------------------------------------------------------------*/
+void aopPut (asmop *aop, char *s, int offset)
+{
+ char *d = buffer ;
+ symbol *lbl ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (aop->size && offset > ( aop->size - 1)) {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopPut got offset > aop->size");
+ exit(0);
+ }
+
+ /* will assign value to value */
+ /* depending on where it is ofcourse */
+ switch (aop->type) {
+ case AOP_DIR:
+ if (offset) {
+ sprintf(d,"(%s + %d)",
+ aop->aopu.aop_dir,offset);
+ fprintf(stderr,"oops aopPut:AOP_DIR did this %s\n",s);
+
+ } else
+ sprintf(d,"%s",aop->aopu.aop_dir);
+
+ if (strcmp(d,s)) {
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ if(strcmp(s,"W"))
+ pic14_emitcode("movf","%s,w",s);
+ pic14_emitcode("movwf","%s",d);
+
+ if(strcmp(s,"W")) {
+ pic14_emitcode(";BUG!? should have this:movf","%s,w %d",s,__LINE__);
+ if(offset >= aop->size) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+ break;
+ } else {
+ emitpcode(POC_MOVFW, popGetImmd(s,0,offset,0));
+ }
+ }
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+
+ }
+ break;
+
+ case AOP_REG:
+ if (strcmp(aop->aopu.aop_reg[offset]->name,s) != 0) {
+ //strcmp(aop->aopu.aop_reg[offset]->dname,s)!= 0){
+ /*
+ if (*s == '@' ||
+ strcmp(s,"r0") == 0 ||
+ strcmp(s,"r1") == 0 ||
+ strcmp(s,"r2") == 0 ||
+ strcmp(s,"r3") == 0 ||
+ strcmp(s,"r4") == 0 ||
+ strcmp(s,"r5") == 0 ||
+ strcmp(s,"r6") == 0 ||
+ strcmp(s,"r7") == 0 )
+ pic14_emitcode("mov","%s,%s ; %d",
+ aop->aopu.aop_reg[offset]->dname,s,__LINE__);
+ else
+ */
+
+ if(strcmp(s,"W")==0 )
+ pic14_emitcode("movf","%s,w ; %d",s,__LINE__);
+
+ pic14_emitcode("movwf","%s",
+ aop->aopu.aop_reg[offset]->name);
+
+ if(strcmp(s,zero)==0) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+
+ } else if(strcmp(s,"W")==0) {
+ pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop->type = PO_GPR_REGISTER;
+
+ PCOR(pcop)->rIdx = -1;
+ PCOR(pcop)->r = NULL;
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ pcop->name = Safe_strdup(s);
+ emitpcode(POC_MOVFW,pcop);
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+ } else if(strcmp(s,one)==0) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+ emitpcode(POC_INCF,popGet(aop,offset));
+ } else {
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+ }
+ }
+ break;
+
+ case AOP_DPTR:
+ case AOP_DPTR2:
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(1);
+ }
+
+ if (aop->code) {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopPut writting to code space");
+ exit(0);
+ }
+
+ while (offset > aop->coff) {
+ aop->coff++;
+ pic14_emitcode ("inc","dptr");
+ }
+
+ while (offset < aop->coff) {
+ aop->coff-- ;
+ pic14_emitcode("lcall","__decdptr");
+ }
+
+ aop->coff = offset;
+
+ /* if not in accumulater */
+ MOVA(s);
+
+ pic14_emitcode ("movx","@dptr,a");
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(0);
+ }
+ break;
+
+ case AOP_R0:
+ case AOP_R1:
+ while (offset > aop->coff) {
+ aop->coff++;
+ pic14_emitcode("inc","%s",aop->aopu.aop_ptr->name);
+ }
+ while (offset < aop->coff) {
+ aop->coff-- ;
+ pic14_emitcode ("dec","%s",aop->aopu.aop_ptr->name);
+ }
+ aop->coff = offset;
+
+ if (aop->paged) {
+ MOVA(s);
+ pic14_emitcode("movx","@%s,a",aop->aopu.aop_ptr->name);
+
+ } else
+ if (*s == '@') {
+ MOVA(s);
+ pic14_emitcode("mov","@%s,a ; %d",aop->aopu.aop_ptr->name,__LINE__);
+ } else
+ if (strcmp(s,"r0") == 0 ||
+ strcmp(s,"r1") == 0 ||
+ strcmp(s,"r2") == 0 ||
+ strcmp(s,"r3") == 0 ||
+ strcmp(s,"r4") == 0 ||
+ strcmp(s,"r5") == 0 ||
+ strcmp(s,"r6") == 0 ||
+ strcmp(s,"r7") == 0 ) {
+ char buffer[10];
+ sprintf(buffer,"a%s",s);
+ pic14_emitcode("mov","@%s,%s",
+ aop->aopu.aop_ptr->name,buffer);
+ } else
+ pic14_emitcode("mov","@%s,%s",aop->aopu.aop_ptr->name,s);
+
+ break;
+
+ case AOP_STK:
+ if (strcmp(s,"a") == 0)
+ pic14_emitcode("push","acc");
+ else
+ pic14_emitcode("push","%s",s);
+
+ break;
+
+ case AOP_CRY:
+ /* if bit variable */
+ if (!aop->aopu.aop_dir) {
+ pic14_emitcode("clr","a");
+ pic14_emitcode("rlc","a");
+ } else {
+ if (s == zero)
+ pic14_emitcode("clr","%s",aop->aopu.aop_dir);
+ else
+ if (s == one)
+ pic14_emitcode("setb","%s",aop->aopu.aop_dir);
+ else
+ if (!strcmp(s,"c"))
+ pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
+ else {
+ lbl = newiTempLabel(NULL);
+
+ if (strcmp(s,"a")) {
+ MOVA(s);
+ }
+ pic14_emitcode("clr","c");
+ pic14_emitcode("jz","%05d_DS_",lbl->key+100);
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",lbl->key+100);
+ pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
+ }
+ }
+ break;
+
+ case AOP_STR:
+ aop->coff = offset;
+ if (strcmp(aop->aopu.aop_str[offset],s))
+ pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s,__LINE__);
+ break;
+
+ case AOP_ACC:
+ aop->coff = offset;
+ if (!offset && (strcmp(s,"acc") == 0))
+ break;
+
+ if (strcmp(aop->aopu.aop_str[offset],s))
+ pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s, __LINE__);
+ break;
+
+ default :
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopPut got unsupported aop->type");
+ exit(0);
+ }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* mov2w_op - generate either a MOVLW or MOVFW based operand type */
+/*-----------------------------------------------------------------*/
+static void mov2w_op (operand *op, int offset)
+{
+ assert (op);
+ FENTRY;
+
+ /* for PO_IMMEDIATEs: use address or value? */
+ if (op_isLitLike (op))
+ {
+ /* access address of op */
+ if (AOP_TYPE(op) != AOP_LIT) { assert (offset < 3); }
+ if (IS_SYMOP(op) && IS_GENPTR(OP_SYM_TYPE(op)) && AOP_SIZE(op) < offset)
+ {
+ if (offset == GPTRSIZE-1)
+ emitpcode (POC_MOVLW, popGetLit (GPTRTAG_DATA));
+ else
+ emitpcode (POC_MOVLW, popGetLit (0));
+ }
+ else
+ emitpcode (POC_MOVLW, popGetAddr(AOP(op), offset, 0));
+ } else {
+ /* access value stored in op */
+ mov2w (AOP(op), offset);
}
+}
- if (sym->accuse)
- {
- int i;
- aop = op->aop = sym->aop = newAsmop (AOP_ACC);
- aop->size = getSize (sym->type);
- for (i = 0; i < 2; i++)
- aop->aopu.aop_str[i] = accUse[i];
- DEBUGemitcode (";", "%d", __LINE__);
- return;
- }
- if (sym->ruonly)
- {
- int i;
- aop = op->aop = sym->aop = newAsmop (AOP_STR);
- aop->size = getSize (sym->type);
- for (i = 0; i < fReturnSize; i++)
- aop->aopu.aop_str[i] = fReturn[i];
- DEBUGemitcode (";", "%d", __LINE__);
- return;
- }
+/*-----------------------------------------------------------------*/
+/* mov2w - generate either a MOVLW or MOVFW based operand type */
+/*-----------------------------------------------------------------*/
+void mov2w (asmop *aop, int offset)
+{
+
+ if(!aop)
+ return;
+
+ DEBUGpic14_emitcode ("; ***","%s %d offset=%d",__FUNCTION__,__LINE__,offset);
+
+ if ( aop_isLitLike (aop) )
+ emitpcode(POC_MOVLW,popGetAddr(aop,offset,0));
+ else
+ emitpcode(POC_MOVFW,popGet(aop,offset));
+
+}
- /* else spill location */
- DEBUGemitcode (";", "%s %d %s", __FUNCTION__, __LINE__, sym->usl.spillLoc->rname);
- sym->aop = op->aop = aop =
- aopForSym (ic, sym->usl.spillLoc, result);
- aop->size = getSize (sym->type);
- return;
- }
+static void movwf (asmop *op, int offset)
+{
+ emitpcode (POC_MOVWF, popGet(op, offset));
+}
- /* must be in a register */
- sym->aop = op->aop = aop = newAsmop (AOP_REG);
- aop->size = sym->nRegs;
- for (i = 0; i < sym->nRegs; i++)
- aop->aopu.aop_reg[i] = sym->regs[i];
+static pCodeOp *get_argument_pcop (int idx)
+{
+ assert (idx > 0 && "the 0th (first) argument is passed via WREG");
+ return popRegFromIdx (Gstack_base_addr - (idx - 1));
}
-/*-----------------------------------------------------------------*/
-/* freeAsmop - free up the asmop given to an operand */
-/*----------------------------------------------------------------*/
-static void
-freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
+static pCodeOp *get_return_val_pcop (int offset)
{
- asmop *aop;
+ assert (offset > 0 && "the most significant byte is returned via WREG");
+ return popRegFromIdx (Gstack_base_addr - (offset - 1));
+}
- if (!op)
- aop = aaop;
- else
- aop = op->aop;
+static void pass_argument (operand *op, int offset, int idx)
+{
+ if (op)
+ mov2w_op (op, offset);
+ if (idx != 0)
+ emitpcode(POC_MOVWF, get_argument_pcop (idx));
+}
- if (!aop)
- return;
+static void get_returnvalue (operand *op, int offset, int idx)
+{
+ if (idx != 0)
+ emitpcode(POC_MOVFW, get_return_val_pcop (idx));
+ movwf(AOP(op), offset);
+}
- if (aop->freed)
- goto dealloc;
+static void call_libraryfunc (char *name)
+{
+ /* library code might reside in different page... */
+ emitpcode (POC_PAGESEL, popGetWithString (name, 1));
+ /* call the library function */
+ emitpcode (POC_CALL, popGetExternal (name));
+ /* might return from different page... */
+ emitpcode (POC_PAGESEL, popGetWithString ("$", 0));
+}
+#if 0
+/*-----------------------------------------------------------------*/
+/* reAdjustPreg - points a register back to where it should */
+/*-----------------------------------------------------------------*/
+static void reAdjustPreg (asmop *aop)
+{
+ int size ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aop->coff = 0;
+ if ((size = aop->size) <= 1)
+ return ;
+ size-- ;
+ switch (aop->type) {
+ case AOP_R0 :
+ case AOP_R1 :
+ while (size--)
+ pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
+ break;
+ case AOP_DPTR :
+ case AOP_DPTR2:
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(1);
+ }
+ while (size--)
+ {
+ pic14_emitcode("lcall","__decdptr");
+ }
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(0);
+ }
+ break;
+
+ }
+
+}
+#endif
- aop->freed = 1;
- /* depending on the asmop type only three cases need work AOP_RO
- , AOP_R1 && AOP_STK */
- switch (aop->type)
- {
- case AOP_R0:
- if (_G.r0Pushed)
+#if 0
+/*-----------------------------------------------------------------*/
+/* opIsGptr: returns non-zero if the passed operand is */
+/* a generic pointer type. */
+/*-----------------------------------------------------------------*/
+static int opIsGptr(operand *op)
+{
+ sym_link *type = operandType(op);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type))
{
- if (pop)
- {
- emitcode ("pop", "ar0");
- _G.r0Pushed--;
- }
+ return 1;
}
- bitVectUnSetBit (ic->rUsed, R0_IDX);
- break;
+ return 0;
+}
+#endif
- case AOP_R1:
- if (_G.r1Pushed)
+/*-----------------------------------------------------------------*/
+/* pic14_getDataSize - get the operand data size */
+/*-----------------------------------------------------------------*/
+int pic14_getDataSize(operand *op)
+{
+ int size;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+#if 0
+ size = getSize(OP_SYM_ETYPE(op));
+ return size;
+ //return AOP_SIZE(op);
+
+ // tsd- in the pic port, the genptr size is 1, so this code here
+ // fails. ( in the 8051 port, the size was 4).
+#else
+ size = AOP_SIZE(op);
+ if (IS_GENPTR(OP_SYM_TYPE(op)))
{
- if (pop)
- {
- emitcode ("pop", "ar1");
- _G.r1Pushed--;
- }
+ sym_link *type = operandType(op);
+ if (IS_GENPTR(type))
+ {
+ /* generic pointer; arithmetic operations
+ * should ignore the high byte (pointer type).
+ */
+ size--;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ }
}
- bitVectUnSetBit (ic->rUsed, R1_IDX);
- break;
-
- case AOP_STK:
- {
- int sz = aop->size;
- int stk = aop->aopu.aop_stk + aop->size;
- bitVectUnSetBit (ic->rUsed, R0_IDX);
- bitVectUnSetBit (ic->rUsed, R1_IDX);
-
- getFreePtr (ic, &aop, FALSE);
-
- if (options.stack10bit)
- {
- /* I'm not sure what to do here yet... */
- /* #STUB */
- fprintf (stderr,
- "*** Warning: probably generating bad code for "
- "10 bit stack mode.\n");
- }
-
- if (stk)
- {
- emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x", ((char) stk) & 0xff);
- emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
- }
- else
- {
- emitcode ("mov", "%s,_bp", aop->aopu.aop_ptr->name);
- }
-
- while (sz--)
- {
- emitcode ("pop", "acc");
- emitcode ("mov", "@%s,a", aop->aopu.aop_ptr->name);
- if (!sz)
- break;
- emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
- }
- op->aop = aop;
- freeAsmop (op, NULL, ic, TRUE);
- if (_G.r0Pushed)
- {
- emitcode ("pop", "ar0");
- _G.r0Pushed--;
- }
-
- if (_G.r1Pushed)
- {
- emitcode ("pop", "ar1");
- _G.r1Pushed--;
- }
- }
- }
+ return size;
+#endif
+}
-dealloc:
- /* all other cases just dealloc */
- if (op)
- {
- op->aop = NULL;
- if (IS_SYMOP (op))
- {
- OP_SYMBOL (op)->aop = NULL;
- /* if the symbol has a spill */
- if (SPIL_LOC (op))
- SPIL_LOC (op)->aop = NULL;
+/*-----------------------------------------------------------------*/
+/* pic14_outAcc - output Acc */
+/*-----------------------------------------------------------------*/
+void pic14_outAcc(operand *result)
+{
+ int size,offset;
+ DEBUGpic14_emitcode ("; ***","%s %d - ",__FUNCTION__,__LINE__);
+ DEBUGpic14_AopType(__LINE__,NULL,NULL,result);
+
+
+ size = pic14_getDataSize(result);
+ if(size){
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+ size--;
+ offset = 1;
+ /* unsigned or positive */
+ while(size--)
+ emitpcode(POC_CLRF,popGet(AOP(result),offset++));
}
- }
+
}
/*-----------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop */
+/* pic14_outBitC - output a bit C */
/*-----------------------------------------------------------------*/
-static char *
-aopGet (asmop * aop, int offset, bool bit16, bool dname)
+void pic14_outBitC(operand *result)
{
- char *s = buffer;
- char *rs;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if the result is bit */
+ if (AOP_TYPE(result) == AOP_CRY)
+ aopPut(AOP(result),"c",0);
+ else {
+ pic14_emitcode("clr","a ; %d", __LINE__);
+ pic14_emitcode("rlc","a");
+ pic14_outAcc(result);
+ }
+}
- //DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* offset is greater than
- size then zero */
- if (offset > (aop->size - 1) &&
- aop->type != AOP_LIT)
- return zero;
+/*-----------------------------------------------------------------*/
+/* pic14_toBoolean - emit code for orl a,operator(sizeop) */
+/*-----------------------------------------------------------------*/
+void pic14_toBoolean(operand *oper)
+{
+ int size = AOP_SIZE(oper);
+ int offset = 0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* depending on type */
- switch (aop->type)
- {
+ assert (size > 0);
- case AOP_R0:
- case AOP_R1:
- DEBUGemitcode (";", "%d", __LINE__);
- /* if we need to increment it */
- while (offset > aop->coff)
- {
- emitcode ("inc", "%s", aop->aopu.aop_ptr->name);
- aop->coff++;
+ if (size == 1) {
+ /* MOVFW does not load the flags... */
+ if (AOP_TYPE(oper) == AOP_ACC) {
+ emitpcode(POC_IORLW, popGetLit(0));
+ offset = 1;
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(0));
+ offset = 0;
+ }
+ } else {
+ if ( AOP_TYPE(oper) != AOP_ACC) {
+ emitpcode(POC_MOVFW,popGet(AOP(oper),0));
+ offset = 1;
+ }
}
-
- while (offset < aop->coff)
- {
- emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
- aop->coff--;
+
+ while (offset < size) {
+ emitpcode(POC_IORFW, popGet(AOP(oper),offset++));
}
+ /* Z is set iff (oper == 0) */
+}
- aop->coff = offset;
- if (aop->paged)
- {
- 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;
-
- case AOP_DPTR:
- case AOP_DPTR2:
- DEBUGemitcode (";", "%d", __LINE__);
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR (1);
- }
- while (offset > aop->coff)
- {
- emitcode ("inc", "dptr");
- aop->coff++;
+/*-----------------------------------------------------------------*/
+/* genNot - generate code for ! operation */
+/*-----------------------------------------------------------------*/
+static void genNot (iCode *ic)
+{
+ //symbol *tlbl;
+ int size;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign asmOps to operand & result */
+ aopOp (IC_LEFT(ic),ic,FALSE);
+ aopOp (IC_RESULT(ic),ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),NULL,IC_RESULT(ic));
+ /* if in bit space then a special case */
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
+ if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+ emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORWF,popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+ emitpcode(POC_CLRF,popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSS,popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_INCF,popGet(AOP(IC_RESULT(ic)),0));
+ }
+ goto release;
}
-
- while (offset < aop->coff)
+
+ size = AOP_SIZE(IC_LEFT(ic));
+ mov2w (AOP(IC_LEFT(ic)),0);
+ while (--size > 0)
{
- emitcode ("lcall", "__decdptr");
- aop->coff--;
+ if (op_isLitLike (IC_LEFT(ic)))
+ emitpcode (POC_IORLW, popGetAddr (AOP(IC_LEFT(ic)), size, 0));
+ else
+ emitpcode (POC_IORFW, popGet (AOP(IC_LEFT(ic)), size));
}
+ emitpcode(POC_MOVLW, popGetLit (0));
+ emitSKPNZ;
+ emitpcode(POC_MOVLW, popGetLit (1));
+ movwf(AOP(IC_RESULT(ic)), 0);
- aop->coff = offset;
- if (aop->code)
+ for (size = 1; size < AOP_SIZE(IC_RESULT(ic)); size++)
{
- emitcode ("clr", "a");
- emitcode ("movc", "a,@a+dptr");
+ emitpcode(POC_CLRF, popGet (AOP(IC_RESULT(ic)), size));
}
- else
- {
- emitcode ("movx", "a,@dptr");
+ goto release;
+
+release:
+ /* release the aops */
+ freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genCpl - generate code for complement */
+/*-----------------------------------------------------------------*/
+static void genCpl (iCode *ic)
+{
+ operand *left, *result;
+ int size, offset=0;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ /* if both are in bit space then
+ a special case */
+ if (AOP_TYPE(result) == AOP_CRY &&
+ AOP_TYPE(left) == AOP_CRY ) {
+
+ pic14_emitcode("mov","c,%s",left->aop->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("mov","%s,c",result->aop->aopu.aop_dir);
+ goto release;
+ }
+
+ size = AOP_SIZE(result);
+ if (AOP_SIZE(left) < size) size = AOP_SIZE(left);
+ while (size--) {
+
+ if(AOP_TYPE(left) == AOP_ACC)
+ emitpcode(POC_XORLW, popGetLit(0xff));
+ else
+ emitpcode(POC_COMFW,popGet(AOP(left),offset));
+
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ offset++;
+ }
+ addSign (result, AOP_SIZE(left), !SPEC_USIGN(operandType(result)));
+
+
+release:
+ /* release the aops */
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(result,NULL,ic,TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genUminusFloat - unary minus for floating points */
+/*-----------------------------------------------------------------*/
+static void genUminusFloat(operand *op,operand *result)
+{
+ int size ,offset =0 ;
+ char *l;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* for this we just need to flip the
+ first it then copy the rest in place */
+ size = AOP_SIZE(op) - 1;
+ l = aopGet(AOP(op),3,FALSE,FALSE);
+
+ MOVA(l);
+
+ pic14_emitcode("cpl","acc.7");
+ aopPut(AOP(result),"a",3);
+
+ while(size--) {
+ aopPut(AOP(result),
+ aopGet(AOP(op),offset,FALSE,FALSE),
+ offset);
+ offset++;
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* genUminus - unary minus code generation */
+/*-----------------------------------------------------------------*/
+static void genUminus (iCode *ic)
+{
+ int size, i;
+ sym_link *optype, *rtype;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign asmops */
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ aopOp(IC_RESULT(ic),ic,TRUE);
+
+ /* if both in bit space then special
+ case */
+ if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
+ AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
+
+ emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSS, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
+
+ goto release;
+ }
+
+ optype = operandType(IC_LEFT(ic));
+ rtype = operandType(IC_RESULT(ic));
+
+ /* if float then do float stuff */
+ if (IS_FLOAT(optype)) {
+ genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
+ goto release;
}
-
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR (0);
+
+ /* otherwise subtract from zero by taking the 2's complement */
+ size = AOP_SIZE(IC_LEFT(ic));
+
+ for(i=0; i<size; i++) {
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
+ emitpcode(POC_COMF, popGet(AOP(IC_LEFT(ic)),i));
+ else {
+ emitpcode(POC_COMFW, popGet(AOP(IC_LEFT(ic)),i));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),i));
+ }
}
-
- return (dname ? "acc" : "a");
-
-
- case AOP_IMMD:
- DEBUGemitcode (";", "%d", __LINE__);
- if (bit16)
- sprintf (s, "%s", aop->aopu.aop_immd);
- else if (offset)
- sprintf (s, "(%s >> %d)",
- aop->aopu.aop_immd,
- offset * 8);
- else
- sprintf (s, "%s",
- aop->aopu.aop_immd);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
-
- case AOP_DIR:
- if (offset)
- sprintf (s, "(%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;
-
- case AOP_REG:
- DEBUGemitcode (";", "%d", __LINE__);
- if (dname)
- return aop->aopu.aop_reg[offset]->dname;
- else
- return aop->aopu.aop_reg[offset]->name;
-
- case AOP_CRY:
- emitcode (";", "%d", __LINE__);
- //emitcode("clr","a");
- //emitcode("mov","c,%s",aop->aopu.aop_dir);
- //emitcode("rlc","a") ;
- //return (dname ? "acc" : "a");
- return aop->aopu.aop_dir;
-
- case AOP_ACC:
- DEBUGemitcode (";Warning -pic port ignoring get(AOP_ACC)", "%d", __LINE__);
- //if (!offset && dname)
- // return "acc";
- //return aop->aopu.aop_str[offset];
- return "AOP_accumulator_bug";
-
- case AOP_LIT:
- DEBUGemitcode (";", "%d", __LINE__);
- return pic14aopLiteral (aop->aopu.aop_lit, offset);
-
- case AOP_STR:
- DEBUGemitcode (";", "%d", __LINE__);
- aop->coff = offset;
- if (strcmp (aop->aopu.aop_str[offset], "a") == 0 &&
- dname)
- return "acc";
-
- return aop->aopu.aop_str[offset];
-
- }
-
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "aopget got unsupported aop->type");
- exit (0);
+
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
+ for(i=1; i<size; i++) {
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),i));
+ }
+
+release:
+ /* release the aops */
+ freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
+
/*-----------------------------------------------------------------*/
-/* aopPut - puts a string for a aop */
+/* saveRegisters - will look for a call and save the registers */
/*-----------------------------------------------------------------*/
-static void
-aopPut (asmop * aop, char *s, int offset)
+static void saveRegisters(iCode *lic)
{
- char *d = buffer;
- symbol *lbl;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
+ int i;
+ iCode *ic;
+ bitVect *rsave;
+ sym_link *dtype;
+
+ FENTRY;
- if (aop->size && offset > (aop->size - 1))
- {
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "aopPut got offset > aop->size");
- exit (0);
- }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* look for call */
+ for (ic = lic ; ic ; ic = ic->next)
+ if (ic->op == CALL || ic->op == PCALL)
+ break;
+
+ if (!ic) {
+ fprintf(stderr,"found parameter push with no function call\n");
+ return ;
+ }
+
+ /* if the registers have been saved already then
+ do nothing */
+ if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type))
+ return ;
+
+ /* find the registers in use at this time
+ and push them away to safety */
+ rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
+ ic->rUsed);
+
+ ic->regsSaved = 1;
+ if (options.useXstack) {
+ if (bitVectBitValue(rsave,R0_IDX))
+ pic14_emitcode("mov","b,r0");
+ pic14_emitcode("mov","r0,%s",spname);
+ for (i = 0 ; i < pic14_nRegs ; i++) {
+ if (bitVectBitValue(rsave,i)) {
+ if (i == R0_IDX)
+ pic14_emitcode("mov","a,b");
+ else
+ pic14_emitcode("mov","a,%s",pic14_regWithIdx(i)->name);
+ pic14_emitcode("movx","@r0,a");
+ pic14_emitcode("inc","r0");
+ }
+ }
+ pic14_emitcode("mov","%s,r0",spname);
+ if (bitVectBitValue(rsave,R0_IDX))
+ pic14_emitcode("mov","r0,b");
+ }// else
+ //for (i = 0 ; i < pic14_nRegs ; i++) {
+ // if (bitVectBitValue(rsave,i))
+ // pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+ //}
+
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
+ IFFUNC_ISISR(currFunc->type) &&
+ !ic->bankSaved)
+
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+}
+/*-----------------------------------------------------------------*/
+/* unsaveRegisters - pop the pushed registers */
+/*-----------------------------------------------------------------*/
+static void unsaveRegisters (iCode *ic)
+{
+ int i;
+ bitVect *rsave;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* find the registers in use at this time
+ and push them away to safety */
+ rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
+ ic->rUsed);
+
+ if (options.useXstack) {
+ pic14_emitcode("mov","r0,%s",spname);
+ for (i = pic14_nRegs ; i >= 0 ; i--) {
+ if (bitVectBitValue(rsave,i)) {
+ pic14_emitcode("dec","r0");
+ pic14_emitcode("movx","a,@r0");
+ if (i == R0_IDX)
+ pic14_emitcode("mov","b,a");
+ else
+ pic14_emitcode("mov","%s,a",pic14_regWithIdx(i)->name);
+ }
+
+ }
+ pic14_emitcode("mov","%s,r0",spname);
+ if (bitVectBitValue(rsave,R0_IDX))
+ pic14_emitcode("mov","r0,b");
+ } //else
+ //for (i = pic14_nRegs ; i >= 0 ; i--) {
+ // if (bitVectBitValue(rsave,i))
+ // pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
+ //}
+
+}
- /* will assign value to value */
- /* depending on where it is ofcourse */
- 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))
- {
- DEBUGemitcode (";", "%d", __LINE__);
- if (strcmp (s, "W"))
- emitcode ("movf", "%s,w", s);
- emitcode ("movwf", "%s", d);
+/*-----------------------------------------------------------------*/
+/* pushSide - */
+/*-----------------------------------------------------------------*/
+static void pushSide(operand * oper, int size)
+{
+#if 0
+ int offset = 0;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ while (size--) {
+ char *l = aopGet(AOP(oper),offset++,FALSE,TRUE);
+ if (AOP_TYPE(oper) != AOP_REG &&
+ AOP_TYPE(oper) != AOP_DIR &&
+ strcmp(l,"a") ) {
+ pic14_emitcode("mov","a,%s",l);
+ pic14_emitcode("push","acc");
+ } else
+ pic14_emitcode("push","%s",l);
}
- break;
+#endif
+}
- case AOP_REG:
- if (strcmp (aop->aopu.aop_reg[offset]->name, s) != 0 &&
- strcmp (aop->aopu.aop_reg[offset]->dname, s) != 0)
- {
- /*
- if (*s == '@' ||
- strcmp(s,"r0") == 0 ||
- strcmp(s,"r1") == 0 ||
- strcmp(s,"r2") == 0 ||
- strcmp(s,"r3") == 0 ||
- strcmp(s,"r4") == 0 ||
- strcmp(s,"r5") == 0 ||
- strcmp(s,"r6") == 0 ||
- strcmp(s,"r7") == 0 )
- emitcode("mov","%s,%s ; %d",
- aop->aopu.aop_reg[offset]->dname,s,__LINE__);
- else
- */
-
- if (strcmp (s, "W"))
- emitcode ("movf", "%s,w ; %d", s, __LINE__);
-
- emitcode ("movwf", "%s",
- aop->aopu.aop_reg[offset]->name);
+/*-----------------------------------------------------------------*/
+/* assignResultValue - */
+/*-----------------------------------------------------------------*/
+static void assignResultValue(operand * oper)
+{
+ int size = AOP_SIZE(oper);
+ int offset = 0;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ DEBUGpic14_AopType(__LINE__,oper,NULL,NULL);
+
+ /* assign MSB first (passed via WREG) */
+ while (size--) {
+ get_returnvalue (oper, size, offset + GpsuedoStkPtr);
+ GpsuedoStkPtr++;
}
- break;
-
- case AOP_DPTR:
- case AOP_DPTR2:
+}
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR (1);
- }
- if (aop->code)
- {
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "aopPut writting to code space");
- exit (0);
- }
+/*-----------------------------------------------------------------*/
+/* genIpush - genrate code for pushing this gets a little complex */
+/*-----------------------------------------------------------------*/
+static void genIpush (iCode *ic)
+{
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+#if 0
+ int size, offset = 0 ;
+ char *l;
+
+
+ /* if this is not a parm push : ie. it is spill push
+ and spill push is always done on the local stack */
+ if (!ic->parmPush) {
+
+ /* and the item is spilt then do nothing */
+ if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
+ return ;
+
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_LEFT(ic));
+ /* push it on the stack */
+ while(size--) {
+ l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
+ if (*l == '#') {
+ MOVA(l);
+ l = "acc";
+ }
+ pic14_emitcode("push","%s",l);
+ }
+ return ;
+ }
+
+ /* this is a paramter push: in this case we call
+ the routine to find the call and save those
+ registers that need to be saved */
+ saveRegisters(ic);
+
+ /* then do the push */
+ aopOp(IC_LEFT(ic),ic,FALSE);
+
+
+ // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
+ size = AOP_SIZE(IC_LEFT(ic));
+
+ while (size--) {
+ l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
+ if (AOP_TYPE(IC_LEFT(ic)) != AOP_REG &&
+ AOP_TYPE(IC_LEFT(ic)) != AOP_DIR &&
+ strcmp(l,"a") ) {
+ pic14_emitcode("mov","a,%s",l);
+ pic14_emitcode("push","acc");
+ } else
+ pic14_emitcode("push","%s",l);
+ }
+
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
+#endif
+}
- while (offset > aop->coff)
- {
- aop->coff++;
- emitcode ("inc", "dptr");
- }
+/*-----------------------------------------------------------------*/
+/* genIpop - recover the registers: can happen only for spilling */
+/*-----------------------------------------------------------------*/
+static void genIpop (iCode *ic)
+{
+ FENTRY;
- while (offset < aop->coff)
- {
- aop->coff--;
- emitcode ("lcall", "__decdptr");
- }
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+ assert (!"genIpop -- unimplemented");
+#if 0
+ int size,offset ;
+
+
+ /* if the temp was not pushed then */
+ if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
+ return ;
+
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_LEFT(ic));
+ offset = (size-1);
+ while (size--)
+ pic14_emitcode("pop","%s",aopGet(AOP(IC_LEFT(ic)),offset--,
+ FALSE,TRUE));
+
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
+#endif
+}
- aop->coff = offset;
+/*-----------------------------------------------------------------*/
+/* unsaverbank - restores the resgister bank from stack */
+/*-----------------------------------------------------------------*/
+static void unsaverbank (int bank,iCode *ic,bool popPsw)
+{
+ FENTRY;
- /* if not in accumulater */
- MOVA (s);
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+#if 0
+ int i;
+ asmop *aop ;
+ regs *r = NULL;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (popPsw) {
+ if (options.useXstack) {
+ aop = newAsmop(0);
+ r = getFreePtr(ic,&aop,FALSE);
+
+
+ pic14_emitcode("mov","%s,_spx",r->name);
+ pic14_emitcode("movx","a,@%s",r->name);
+ pic14_emitcode("mov","psw,a");
+ pic14_emitcode("dec","%s",r->name);
+
+ }else
+ pic14_emitcode ("pop","psw");
+ }
+
+ for (i = (pic14_nRegs - 1) ; i >= 0 ;i--) {
+ if (options.useXstack) {
+ pic14_emitcode("movx","a,@%s",r->name);
+ //pic14_emitcode("mov","(%s+%d),a",
+ // regspic14[i].base,8*bank+regspic14[i].offset);
+ pic14_emitcode("dec","%s",r->name);
+
+ } else
+ pic14_emitcode("pop",""); //"(%s+%d)",
+ //regspic14[i].base,8*bank); //+regspic14[i].offset);
+ }
+
+ if (options.useXstack) {
+
+ pic14_emitcode("mov","_spx,%s",r->name);
+ freeAsmop(NULL,aop,ic,TRUE);
+
+ }
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* saverbank - saves an entire register bank on the stack */
+/*-----------------------------------------------------------------*/
+static void saverbank (int bank, iCode *ic, bool pushPsw)
+{
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+#if 0
+ int i;
+ asmop *aop ;
+ regs *r = NULL;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (options.useXstack) {
+
+ aop = newAsmop(0);
+ r = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,_spx",r->name);
+
+ }
+
+ for (i = 0 ; i < pic14_nRegs ;i++) {
+ if (options.useXstack) {
+ pic14_emitcode("inc","%s",r->name);
+ //pic14_emitcode("mov","a,(%s+%d)",
+ // regspic14[i].base,8*bank+regspic14[i].offset);
+ pic14_emitcode("movx","@%s,a",r->name);
+ } else
+ pic14_emitcode("push","");// "(%s+%d)",
+ //regspic14[i].base,8*bank+regspic14[i].offset);
+ }
+
+ if (pushPsw) {
+ if (options.useXstack) {
+ pic14_emitcode("mov","a,psw");
+ pic14_emitcode("movx","@%s,a",r->name);
+ pic14_emitcode("inc","%s",r->name);
+ pic14_emitcode("mov","_spx,%s",r->name);
+ freeAsmop (NULL,aop,ic,TRUE);
+
+ } else
+ pic14_emitcode("push","psw");
+
+ pic14_emitcode("mov","psw,#0x%02x",(bank << 3)&0x00ff);
+ }
+ ic->bankSaved = 1;
+#endif
+}
- emitcode ("movx", "@dptr,a");
+/*-----------------------------------------------------------------*/
+/* genCall - generates a call statement */
+/*-----------------------------------------------------------------*/
+static void genCall (iCode *ic)
+{
+ sym_link *dtype;
+ symbol *sym;
+ char *name;
+ int isExtern;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* if caller saves & we have not saved then */
+ if (!ic->regsSaved)
+ saveRegisters(ic);
+
+ /* if we are calling a function that is not using
+ the same register bank then we need to save the
+ destination registers on the stack */
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
+ IFFUNC_ISISR(currFunc->type) &&
+ !ic->bankSaved)
+
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ /* if send set is not empty the assign */
+ if (_G.sendSet) {
+ iCode *sic;
+ /* For the Pic port, there is no data stack.
+ * So parameters passed to functions are stored
+ * in registers. (The pCode optimizer will get
+ * rid of most of these :).
+ */
+ int psuedoStkPtr=-1;
+ int firstTimeThruLoop = 1;
+
+ _G.sendSet = reverseSet(_G.sendSet);
+
+ /* First figure how many parameters are getting passed */
+ for (sic = setFirstItem(_G.sendSet) ; sic ;
+ sic = setNextItem(_G.sendSet)) {
+
+ aopOp(IC_LEFT(sic),sic,FALSE);
+ psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
+ freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
+ }
+
+ for (sic = setFirstItem(_G.sendSet) ; sic ;
+ sic = setNextItem(_G.sendSet)) {
+ int size, offset = 0;
+
+ aopOp(IC_LEFT(sic),sic,FALSE);
+ size = AOP_SIZE(IC_LEFT(sic));
+
+ while (size--) {
+ DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
+ AopType(AOP_TYPE(IC_LEFT(sic))));
+
+ if(!firstTimeThruLoop) {
+ /* If this is not the first time we've been through the loop
+ * then we need to save the parameter in a temporary
+ * register. The last byte of the last parameter is
+ * passed in W. */
+ emitpcode(POC_MOVWF,popRegFromIdx(Gstack_base_addr - --psuedoStkPtr));
+
+ }
+ firstTimeThruLoop=0;
+
+ mov2w_op (IC_LEFT(sic), offset);
+ offset++;
+ }
+ freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
+ }
+ _G.sendSet = NULL;
+ }
+ /* make the call */
+ sym = OP_SYMBOL(IC_LEFT(ic));
+ name = sym->rname[0] ? sym->rname : sym->name;
+ isExtern = IS_EXTERN(sym->etype) || pic14_inISR;
+ if (isExtern) {
+ /* Extern functions and ISRs maybe on a different page;
+ * must call pagesel */
+ emitpcode(POC_PAGESEL,popGetWithString(name,1));
+ }
+ emitpcode(POC_CALL,popGetWithString(name,isExtern));
+ if (isExtern) {
+ /* May have returned from a different page;
+ * must use pagesel to restore PCLATH before next
+ * goto or call instruction */
+ emitpcode(POC_PAGESEL,popGetWithString("$",0));
+ }
+ GpsuedoStkPtr=0;
+ /* if we need assign a result value */
+ if ((IS_ITEMP(IC_RESULT(ic)) &&
+ (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
+ OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
+ IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
+
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+
+ assignResultValue(IC_RESULT(ic));
+
+ DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
+ AopType(AOP_TYPE(IC_RESULT(ic))));
+
+ freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
+ }
+
+ /* if register bank was saved then pop them */
+ if (ic->bankSaved)
+ unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ /* if we hade saved some registers then unsave them */
+ if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+ unsaveRegisters (ic);
+
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genPcall - generates a call by pointer statement */
+/*-----------------------------------------------------------------*/
+static void genPcall (iCode *ic)
+{
+ sym_link *dtype;
+ symbol *albl = newiTempLabel(NULL);
+ symbol *blbl = newiTempLabel(NULL);
+ PIC_OPCODE poc;
+ pCodeOp *pcop;
+ operand *left;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if caller saves & we have not saved then */
+ if (!ic->regsSaved)
+ saveRegisters(ic);
+
+ /* if we are calling a function that is not using
+ the same register bank then we need to save the
+ destination registers on the stack */
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ IFFUNC_ISISR(currFunc->type) &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ left = IC_LEFT(ic);
+ aopOp(left,ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,left,NULL,NULL);
+
+ poc = ( op_isLitLike (IC_LEFT(ic)) ? POC_MOVLW : POC_MOVFW );
+
+ pushSide(IC_LEFT(ic), FPTRSIZE);
+
+ /* if send set is not empty, assign parameters */
+ if (_G.sendSet) {
+
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING arg-passing to indirect call not supported",__FUNCTION__,__LINE__);
+ /* no way to pass args - W always gets used to make the call */
+ }
+ /* first idea - factor out a common helper function and call it.
+ But don't know how to get it generated only once in its own block
+
+ if(AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) {
+ char *rname;
+ char *buffer;
+ rname = IC_LEFT(ic)->aop->aopu.aop_dir;
+ DEBUGpic14_emitcode ("; ***","%s %d AOP_DIR %s",__FUNCTION__,__LINE__,rname);
+ buffer = Safe_calloc(1,strlen(rname)+16);
+ sprintf(buffer, "%s_goto_helper", rname);
+ addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp(buffer,PO_STR)));
+ free(buffer);
+ }
+ */
+ emitpcode(POC_CALL,popGetLabel(albl->key));
+ pcop = popGetLabel(blbl->key);
+ emitpcode(POC_PAGESEL,pcop); /* Must restore PCLATH before goto, without destroying W */
+ emitpcode(POC_GOTO,pcop);
+ emitpLabel(albl->key);
+
+ emitpcode(poc,popGetAddr(AOP(left),1,0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
+ emitpcode(poc,popGetAddr(AOP(left),0,0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
+
+ emitpLabel(blbl->key);
+
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
+
+ /* if we need to assign a result value */
+ if ((IS_ITEMP(IC_RESULT(ic)) &&
+ (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
+ OP_SYMBOL(IC_RESULT(ic))->spildir)) ||
+ IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
+
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+
+ GpsuedoStkPtr = 0;
+
+ assignResultValue(IC_RESULT(ic));
+
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ }
+
+ /* if register bank was saved then unsave them */
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
+ unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ /* if we hade saved some registers then
+ unsave them */
+ if (ic->regsSaved)
+ unsaveRegisters (ic);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* resultRemat - result is rematerializable */
+/*-----------------------------------------------------------------*/
+static int resultRemat (iCode *ic)
+{
+ // DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ FENTRY;
+
+ if (SKIP_IC(ic) || ic->op == IFX)
+ return 0;
+
+ if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
+ symbol *sym = OP_SYMBOL(IC_RESULT(ic));
+ if (sym->remat && !POINTER_SET(ic))
+ return 1;
+ }
+
+ return 0;
+}
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR (0);
- }
- break;
+#if 0
+/*-----------------------------------------------------------------*/
+/* inExcludeList - return 1 if the string is in exclude Reg list */
+/*-----------------------------------------------------------------*/
+static bool inExcludeList(char *s)
+{
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+ int i =0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (options.excludeRegs[i] &&
+ STRCASECMP(options.excludeRegs[i],"none") == 0)
+ return FALSE ;
+
+ for ( i = 0 ; options.excludeRegs[i]; i++) {
+ if (options.excludeRegs[i] &&
+ STRCASECMP(s,options.excludeRegs[i]) == 0)
+ return TRUE;
+ }
+ return FALSE ;
+}
+#endif
- case AOP_R0:
- case AOP_R1:
- while (offset > aop->coff)
- {
- aop->coff++;
- emitcode ("inc", "%s", aop->aopu.aop_ptr->name);
+/*-----------------------------------------------------------------*/
+/* genFunction - generated code for function entry */
+/*-----------------------------------------------------------------*/
+static void genFunction (iCode *ic)
+{
+ symbol *sym;
+ sym_link *ftype;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
+
+ labelOffset += (max_key+4);
+ max_key=0;
+ GpsuedoStkPtr=0;
+ _G.nRegsSaved = 0;
+ /* create the function header */
+ pic14_emitcode(";","-----------------------------------------");
+ pic14_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
+ pic14_emitcode(";","-----------------------------------------");
+
+ /* prevent this symbol from being emitted as 'extern' */
+ pic14_stringInSet(sym->rname, &pic14_localFunctions, 1);
+
+ pic14_emitcode("","%s:",sym->rname);
+ addpCode2pBlock(pb,newpCodeFunction(NULL,sym->rname,!IS_STATIC (sym->etype)));
+
+ ftype = operandType(IC_LEFT(ic));
+
+ /* if critical function then turn interrupts off */
+ if (IFFUNC_ISCRITICAL(ftype))
+ pic14_emitcode("clr","ea");
+
+ /* here we need to generate the equates for the
+ register bank if required */
+#if 0
+ if (FUNC_REGBANK(ftype) != rbank) {
+ int i ;
+
+ rbank = FUNC_REGBANK(ftype);
+ for ( i = 0 ; i < pic14_nRegs ; i++ ) {
+ if (strcmp(regspic14[i].base,"0") == 0)
+ pic14_emitcode("","%s = 0x%02x",
+ regspic14[i].dname,
+ 8*rbank+regspic14[i].offset);
+ else
+ pic14_emitcode ("","%s = %s + 0x%02x",
+ regspic14[i].dname,
+ regspic14[i].base,
+ 8*rbank+regspic14[i].offset);
+ }
}
- while (offset < aop->coff)
- {
- aop->coff--;
- emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
+#endif
+
+ /* if this is an interrupt service routine */
+ pic14_inISR = 0;
+ if (IFFUNC_ISISR(sym->type)) {
+ pic14_inISR = 1;
+ /* already done in pic14createInterruptVect() - delete me
+ addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("END_OF_INTERRUPT+1",PO_STR)));
+ emitpcodeNULLop(POC_NOP);
+ emitpcodeNULLop(POC_NOP);
+ emitpcodeNULLop(POC_NOP);
+ */
+ emitpcode(POC_MOVWF, popCopyReg(&pc_wsave));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_status));
+ emitpcode(POC_CLRF, popCopyReg(&pc_status));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_ssave));
+ emitpcode(POC_MOVFW, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_psave));
+ emitpcode(POC_CLRF, popCopyReg(&pc_pclath));/* during an interrupt PCLATH must be cleared before a goto or call statement */
+
+ pBlockConvert2ISR(pb);
+ pic14_hasInterrupt = 1;
+#if 0
+ if (!inExcludeList("acc"))
+ pic14_emitcode ("push","acc");
+ if (!inExcludeList("b"))
+ pic14_emitcode ("push","b");
+ if (!inExcludeList("dpl"))
+ pic14_emitcode ("push","dpl");
+ if (!inExcludeList("dph"))
+ pic14_emitcode ("push","dph");
+ if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
+ {
+ pic14_emitcode ("push", "dpx");
+ /* Make sure we're using standard DPTR */
+ pic14_emitcode ("push", "dps");
+ pic14_emitcode ("mov", "dps, #0x00");
+ if (options.stack10bit)
+ {
+ /* This ISR could conceivably use DPTR2. Better save it. */
+ pic14_emitcode ("push", "dpl1");
+ pic14_emitcode ("push", "dph1");
+ pic14_emitcode ("push", "dpx1");
+ }
+ }
+ /* if this isr has no bank i.e. is going to
+ run with bank 0 , then we need to save more
+ registers :-) */
+ if (!FUNC_REGBANK(sym->type)) {
+
+ /* 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) {
+ /* save the registers used */
+ for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic14_emitcode("push","junk");//"%s",pic14_regWithIdx(i)->dname);
+ }
+ }
+
+ } else {
+ /* this function has a function call cannot
+ determines register usage so we will have the
+ entire bank */
+ saverbank(0,ic,FALSE);
+ }
+ }
+#endif
+ } else {
+ /* if callee-save to be used for this function
+ then save the registers being used in this function */
+ if (IFFUNC_CALLEESAVES(sym->type)) {
+ int i;
+
+ /* if any registers used */
+ if (sym->regsUsed) {
+ /* save the registers used */
+ for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
+ //pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+ _G.nRegsSaved++;
+ }
+ }
+ }
+ }
}
- aop->coff = offset;
-
- if (aop->paged)
- {
- MOVA (s);
- emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name);
-
+
+ /* set the register bank to the desired value */
+ if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type)) {
+ pic14_emitcode("push","psw");
+ pic14_emitcode("mov","psw,#0x%02x",(FUNC_REGBANK(sym->type) << 3)&0x00ff);
+ }
+
+ if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
+
+ if (options.useXstack) {
+ pic14_emitcode("mov","r0,%s",spname);
+ pic14_emitcode("mov","a,_bp");
+ pic14_emitcode("movx","@r0,a");
+ pic14_emitcode("inc","%s",spname);
+ }
+ else
+ {
+ /* set up the stack */
+ pic14_emitcode ("push","_bp"); /* save the callers stack */
+ }
+ pic14_emitcode ("mov","_bp,%s",spname);
+ }
+
+ /* adjust the stack for the function */
+ if (sym->stack) {
+
+ int i = sym->stack;
+ if (i > 256 )
+ werror(W_STACK_OVERFLOW,sym->name);
+
+ if (i > 3 && sym->recvSize < 4) {
+
+ pic14_emitcode ("mov","a,sp");
+ pic14_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
+ pic14_emitcode ("mov","sp,a");
+
+ }
+ else
+ while(i--)
+ pic14_emitcode("inc","sp");
}
- else if (*s == '@')
- {
- MOVA (s);
- emitcode ("mov", "@%s,a ; %d", aop->aopu.aop_ptr->name, __LINE__);
- }
- else if (strcmp (s, "r0") == 0 ||
- strcmp (s, "r1") == 0 ||
- strcmp (s, "r2") == 0 ||
- strcmp (s, "r3") == 0 ||
- strcmp (s, "r4") == 0 ||
- strcmp (s, "r5") == 0 ||
- strcmp (s, "r6") == 0 ||
- strcmp (s, "r7") == 0)
- {
- char buffer[10];
- sprintf (buffer, "a%s", s);
- emitcode ("mov", "@%s,%s",
- aop->aopu.aop_ptr->name, buffer);
+
+ if (sym->xstack) {
+
+ pic14_emitcode ("mov","a,_spx");
+ pic14_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
+ pic14_emitcode ("mov","_spx,a");
}
- 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);
+
+}
- break;
+/*-----------------------------------------------------------------*/
+/* genEndFunction - generates epilogue for functions */
+/*-----------------------------------------------------------------*/
+static void genEndFunction (iCode *ic)
+{
+ symbol *sym = OP_SYMBOL(IC_LEFT(ic));
+
+ FENTRY;
- case AOP_CRY:
- /* if bit variable */
- if (!aop->aopu.aop_dir)
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (IFFUNC_ISREENT(sym->type) || options.stackAuto)
{
- emitcode ("clr", "a");
- emitcode ("rlc", "a");
+ pic14_emitcode ("mov","%s,_bp",spname);
}
- else
- {
- if (s == zero)
- emitcode ("clr", "%s", aop->aopu.aop_dir);
- else if (s == one)
- emitcode ("setb", "%s", aop->aopu.aop_dir);
- else if (!strcmp (s, "c"))
- emitcode ("mov", "%s,c", aop->aopu.aop_dir);
- else
- {
- lbl = newiTempLabel (NULL);
-
- if (strcmp (s, "a"))
+
+ /* if use external stack but some variables were
+ added to the local stack then decrement the
+ local stack */
+ if (options.useXstack && sym->stack) {
+ pic14_emitcode("mov","a,sp");
+ pic14_emitcode("add","a,#0x%02x",((char)-sym->stack) & 0xff);
+ pic14_emitcode("mov","sp,a");
+ }
+
+
+ if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) {
+ if (options.useXstack) {
+ pic14_emitcode("mov","r0,%s",spname);
+ pic14_emitcode("movx","a,@r0");
+ pic14_emitcode("mov","_bp,a");
+ pic14_emitcode("dec","%s",spname);
+ }
+ else
{
- MOVA (s);
+ pic14_emitcode ("pop","_bp");
}
- emitcode ("clr", "c");
- emitcode ("jz", "%05d_DS_", lbl->key + 100);
- emitcode ("cpl", "c");
- emitcode ("", "%05d_DS_:", lbl->key + 100);
- emitcode ("mov", "%s,c", aop->aopu.aop_dir);
- }
}
- break;
-
- case AOP_STR:
- aop->coff = offset;
- if (strcmp (aop->aopu.aop_str[offset], s))
- emitcode ("mov", "%s,%s ; %d", aop->aopu.aop_str[offset], s, __LINE__);
- break;
-
- case AOP_ACC:
- aop->coff = offset;
- if (!offset && (strcmp (s, "acc") == 0))
- break;
-
- if (strcmp (aop->aopu.aop_str[offset], s))
- emitcode ("mov", "%s,%s ; %d", aop->aopu.aop_str[offset], s, __LINE__);
- break;
-
- default:
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "aopPut got unsupported aop->type");
- exit (0);
- }
-
+
+ /* restore the register bank */
+ if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type))
+ pic14_emitcode ("pop","psw");
+
+ if (IFFUNC_ISISR(sym->type)) {
+
+ /* now we need to restore the registers */
+ /* if this isr has no bank i.e. is going to
+ run with bank 0 , then we need to save more
+registers :-) */
+ if (!FUNC_REGBANK(sym->type)) {
+
+ /* 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) {
+ /* save the registers used */
+ for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
+ }
+ }
+
+ } else {
+ /* this function has a function call cannot
+ determines register usage so we will have the
+ entire bank */
+ unsaverbank(0,ic,FALSE);
+ }
+ }
+#if 0
+ if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
+ {
+ if (options.stack10bit)
+ {
+ pic14_emitcode ("pop", "dpx1");
+ pic14_emitcode ("pop", "dph1");
+ pic14_emitcode ("pop", "dpl1");
+ }
+ pic14_emitcode ("pop", "dps");
+ pic14_emitcode ("pop", "dpx");
+ }
+ if (!inExcludeList("dph"))
+ pic14_emitcode ("pop","dph");
+ if (!inExcludeList("dpl"))
+ pic14_emitcode ("pop","dpl");
+ if (!inExcludeList("b"))
+ pic14_emitcode ("pop","b");
+ if (!inExcludeList("acc"))
+ pic14_emitcode ("pop","acc");
+
+ if (IFFUNC_ISCRITICAL(sym->type))
+ pic14_emitcode("setb","ea");
+#endif
+
+ /* if debug then send end of function */
+ /* if (options.debug && currFunc) { */
+ if (currFunc) {
+ debugFile->writeEndFunction (currFunc, ic, 1);
+ }
+
+ pic14_emitcode ("reti","");
+ emitpcode(POC_MOVFW, popCopyReg(&pc_psave));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
+ emitpcode(POC_CLRF, popCopyReg(&pc_status));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_status));
+ emitpcode(POC_SWAPF, popCopyReg(&pc_wsave));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_wsave));
+ addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
+ emitpcodeNULLop(POC_RETFIE);
+ }
+ else {
+ if (IFFUNC_ISCRITICAL(sym->type))
+ pic14_emitcode("setb","ea");
+
+ if (IFFUNC_CALLEESAVES(sym->type)) {
+ int i;
+
+ /* if any registers used */
+ if (sym->regsUsed) {
+ /* save the registers used */
+ for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
+ }
+ }
+
+ }
+
+ /* if debug then send end of function */
+ if (currFunc) {
+ debugFile->writeEndFunction (currFunc, ic, 1);
+ }
+
+ pic14_emitcode ("return","");
+ emitpcodeNULLop(POC_RETURN);
+
+ /* Mark the end of a function */
+ addpCode2pBlock(pb,newpCodeFunction(NULL,NULL,0));
+ }
+
}
/*-----------------------------------------------------------------*/
-/* reAdjustPreg - points a register back to where it should */
+/* genRet - generate code for return statement */
/*-----------------------------------------------------------------*/
-static void
-reAdjustPreg (asmop * aop)
+static void genRet (iCode *ic)
{
- int size;
+ int size,offset = 0;
+
+ FENTRY;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aop->coff = 0;
- if ((size = aop->size) <= 1)
- return;
- size--;
- switch (aop->type)
- {
- case AOP_R0:
- case AOP_R1:
- while (size--)
- emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
- break;
- case AOP_DPTR:
- case AOP_DPTR2:
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR (1);
- }
- while (size--)
- {
- emitcode ("lcall", "__decdptr");
- }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if we have no return value then
+ just generate the "ret" */
+ if (!IC_LEFT(ic))
+ goto jumpret;
+
+ /* we have something to return then
+ move the return value into place */
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_LEFT(ic));
- if (aop->type == AOP_DPTR2)
+ for (offset = 0; offset < size; offset++)
{
- genSetDPTR (0);
+ pass_argument (IC_LEFT(ic), offset, size - 1 - offset);
}
- break;
-
- }
-
+
+ freeAsmop (IC_LEFT(ic),NULL,ic,TRUE);
+
+jumpret:
+ /* generate a jump to the return label
+ if the next is not the return statement */
+ if (!(ic->next && ic->next->op == LABEL &&
+ IC_LABEL(ic->next) == returnLabel)) {
+
+ emitpcode(POC_GOTO,popGetLabel(returnLabel->key));
+ }
+
}
-#define AOP(op) op->aop
-#define AOP_TYPE(op) AOP(op)->type
-#define AOP_SIZE(op) AOP(op)->size
-#define IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \
- AOP_TYPE(x) == AOP_R0))
-
-#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \
- AOP_TYPE(x) == AOP_DPTR || AOP_TYPE(x) == AOP_DPTR2 || \
- AOP(x)->paged))
+/*-----------------------------------------------------------------*/
+/* genLabel - generates a label */
+/*-----------------------------------------------------------------*/
+static void genLabel (iCode *ic)
+{
+ FENTRY;
-#define AOP_INPREG(x) (x && (x->type == AOP_REG && \
- (x->aopu.aop_reg[0] == pic14_regWithIdx(R0_IDX) || \
- x->aopu.aop_reg[0] == pic14_regWithIdx(R1_IDX) )))
+ /* special case never generate */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (IC_LABEL(ic) == entryLabel)
+ return ;
+
+ emitpLabel(IC_LABEL(ic)->key);
+ pic14_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + labelOffset));
+}
/*-----------------------------------------------------------------*/
-/* genNotFloat - generates not for float operations */
+/* genGoto - generates a goto */
/*-----------------------------------------------------------------*/
-static void
-genNotFloat (operand * op, operand * res)
+//tsd
+static void genGoto (iCode *ic)
{
- int size, offset;
- char *l;
- symbol *tlbl;
+ FENTRY;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* we will put 127 in the first byte of
- the result */
- aopPut (AOP (res), "#127", 0);
- size = AOP_SIZE (op) - 1;
- offset = 1;
+ emitpcode(POC_GOTO,popGetLabel(IC_LABEL(ic)->key));
+ pic14_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+labelOffset);
+}
- l = aopGet (op->aop, offset++, FALSE, FALSE);
- MOVA (l);
- while (size--)
- {
- emitcode ("orl", "a,%s",
- aopGet (op->aop,
- offset++, FALSE, FALSE));
- }
- tlbl = newiTempLabel (NULL);
+/*-----------------------------------------------------------------*/
+/* genMultbits :- multiplication of bits */
+/*-----------------------------------------------------------------*/
+static void genMultbits (operand *left,
+ operand *right,
+ operand *result)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(!pic14_sameRegs(AOP(result),AOP(right)))
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ emitpcode(POC_BTFSC,popGet(AOP(right),0));
+ emitpcode(POC_BTFSS,popGet(AOP(left),0));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genMultOneByte : 8 bit multiplication & division */
+/*-----------------------------------------------------------------*/
+static void genMultOneByte (operand *left,
+ operand *right,
+ operand *result)
+{
+ char *func[] = { NULL, "__mulchar", "__mulint", NULL, "__mullong" };
+
+ // symbol *lbl ;
+ int size,offset,i;
+
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+ DEBUGpic14_AopTypeSign(__LINE__,left,right,result);
+
+ /* (if two literals, the value is computed before) */
+ /* if one literal, literal on the right */
+ if (AOP_TYPE(left) == AOP_LIT){
+ operand *t = right;
+ right = left;
+ left = t;
+ }
+
+ assert (AOP_SIZE(left) == AOP_SIZE(right));
+
+ size = min(AOP_SIZE(result),AOP_SIZE(left));
+ offset = Gstack_base_addr - (2*size - 1);
+
+ /* pass right operand as argument */
+ for (i=0; i < size; i++)
+ {
+ mov2w (AOP(right), i);
+ emitpcode(POC_MOVWF, popRegFromIdx (++offset));
+ } // for
+
+ /* pass left operand as argument */
+ for (i=0; i < size; i++)
+ {
+ mov2w (AOP(left), i);
+ if (i != size-1) emitpcode(POC_MOVWF, popRegFromIdx (++offset));
+ } // for
+ assert (offset == Gstack_base_addr);
+
+ /* call library routine */
+ assert (size > 0 && size <= 4);
+ call_libraryfunc (func[size]);
+
+ /* assign result */
+ movwf (AOP(result), size-1);
+ for (i=0; i < size - 1; i++)
+ {
+ emitpcode(POC_MOVFW, popRegFromIdx (Gstack_base_addr - i));
+ movwf (AOP(result), size - 2 - i);
+ } // for
+
+ /* now (zero-/sign) extend the result to its size */
+ addSign (result, AOP_SIZE(left), !SPEC_USIGN(operandType(result)));
+}
+
+/*-----------------------------------------------------------------*/
+/* genMult - generates code for multiplication */
+/*-----------------------------------------------------------------*/
+static void genMult (iCode *ic)
+{
+ operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ operand *result= IC_RESULT(ic);
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ /* special cases first */
+ /* both are bits */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right)== AOP_CRY) {
+ genMultbits(left,right,result);
+ goto release ;
+ }
+
+ /* if both are of size == 1 */
+ if (AOP_SIZE(left) == 1 &&
+ AOP_SIZE(right) == 1 ) {
+ genMultOneByte(left,right,result);
+ goto release ;
+ }
+
+ /* should have been converted to function call */
+ assert(0) ;
+
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDivbits :- division of bits */
+/*-----------------------------------------------------------------*/
+static void genDivbits (operand *left,
+ operand *right,
+ operand *result)
+{
+
+ char *l;
+
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* the result must be bit */
+ pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+
+ MOVA(l);
+
+ pic14_emitcode("div","ab");
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"c",0);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDivOneByte : 8 bit division */
+/*-----------------------------------------------------------------*/
+static void genDivOneByte (operand *left,
+ operand *right,
+ operand *result)
+{
+ int size;
+ int sign;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ assert (AOP_SIZE(right) == 1);
+ assert (AOP_SIZE(left) == 1);
+
+ size = min(AOP_SIZE(result),AOP_SIZE(left));
+ sign = !(SPEC_USIGN(operandType(left))
+ && SPEC_USIGN(operandType(right)));
+
+ if (AOP_TYPE(right) == AOP_LIT)
+ {
+ /* XXX: might add specialized code */
+ }
+
+ if (!sign)
+ {
+ /* unsigned division */
+ #if 1
+ mov2w(AOP(right),0);
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ mov2w(AOP(left),0);
+ call_libraryfunc("__divuchar");
+ movwf(AOP(result),0);
+ #else
+ pCodeOp *temp;
+ symbol *lbl;
+
+ temp = popGetTempReg();
+ lbl = newiTempLabel(NULL);
+
+ /* XXX: improve this naive approach:
+ [result] = [a] / [b]
+ ::= [result] = 0; while ([a] > [b]) do [a] -= [b]; [result]++ done
+
+ In PIC assembler:
+ movf left,W
+ movwf temp // temp <-- left
+ movf right,W // W <-- right
+ clrf result
+ label1:
+ incf result
+ subwf temp,F // temp <-- temp - W
+ skipNC // subwf clears CARRY (i.e. sets BORROW) if temp < W
+ goto label1
+ decf result // we just subtract once too often
+ */
+
+ /* XXX: This loops endlessly on DIVIDE BY ZERO */
+ /* We need 1..128 iterations of the loop body (`4 / 5' .. `255 / 2'). */
+
+ mov2w(AOP(left),0);
+ emitpcode(POC_MOVWF, temp);
+ mov2w(AOP(right),0);
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+
+ emitpLabel(lbl->key);
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+ emitpcode(POC_SUBWF, temp);
+ emitSKPNC;
+ emitpcode(POC_GOTO, popGetLabel(lbl->key));
+ emitpcode(POC_DECF, popGet(AOP(result),0));
+ #endif
+ }
+ else
+ {
+ /* signed division */
+ mov2w(AOP(right),0);
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ mov2w(AOP(left),0);
+ call_libraryfunc("__divschar");
+ movwf(AOP(result),0);
+ }
+
+ /* now performed the signed/unsigned division -- extend result */
+ addSign(result, 1, sign);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDiv - generates code for division */
+/*-----------------------------------------------------------------*/
+static void genDiv (iCode *ic)
+{
+ operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ operand *result= IC_RESULT(ic);
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ /* special cases first */
+ /* both are bits */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right)== AOP_CRY) {
+ genDivbits(left,right,result);
+ goto release ;
+ }
+
+ /* if both are of size == 1 */
+ if (AOP_SIZE(left) == 1 &&
+ AOP_SIZE(right) == 1 ) {
+ genDivOneByte(left,right,result);
+ goto release ;
+ }
+
+ /* should have been converted to function call */
+ assert(0);
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genModOneByte : 8 bit modulus */
+/*-----------------------------------------------------------------*/
+static void genModOneByte (operand *left,
+ operand *right,
+ operand *result)
+{
+ int size;
+ int sign;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ assert (AOP_SIZE(right) == 1);
+ assert (AOP_SIZE(left) == 1);
+
+ size = min(AOP_SIZE(result),AOP_SIZE(left));
+ sign = !(SPEC_USIGN(operandType(left))
+ && SPEC_USIGN(operandType(right)));
+
+ if (AOP_TYPE(right) == AOP_LIT)
+ {
+ /* XXX: might add specialized code */
+ }
+
+ if (!sign)
+ {
+ /* unsigned division */
+ #if 1
+ mov2w(AOP(right),0);
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ mov2w(AOP(left),0);
+ call_libraryfunc("__moduchar");
+ movwf(AOP(result),0);
+ #else
+ pCodeOp *temp;
+ symbol *lbl;
+
+ lbl = newiTempLabel(NULL);
+
+ assert(!pic14_sameRegs(AOP(right),AOP(result)));
+
+ /* XXX: improve this naive approach:
+ [result] = [a] % [b]
+ ::= [result] = [a]; while ([result] > [b]) do [result] -= [b]; done
+
+ In PIC assembler:
+ movf left,W
+ movwf result // result <-- left
+ movf right,W // W <-- right
+ label1:
+ subwf result,F // result <-- result - W
+ skipNC // subwf clears CARRY (i.e. sets BORROW) if result < W
+ goto label1
+ addwf result, F // we just subtract once too often
+ */
+
+ /* XXX: This loops endlessly on DIVIDE BY ZERO */
+ /* We need 1..128 iterations of the loop body (`4 % 5' .. `255 % 2'). */
+
+ if (!pic14_sameRegs(AOP(left), AOP(result)))
+ {
+ mov2w(AOP(left),0);
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ }
+ mov2w(AOP(right),0);
- tlbl = newiTempLabel (NULL);
- aopPut (res->aop, one, 1);
- emitcode ("jz", "%05d_DS_", (tlbl->key + 100));
- aopPut (res->aop, zero, 1);
- emitcode ("", "%05d_DS_:", (tlbl->key + 100));
+ emitpLabel(lbl->key);
+ emitpcode(POC_SUBWF, popGet(AOP(result),0));
+ emitSKPNC;
+ emitpcode(POC_GOTO, popGetLabel(lbl->key));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ #endif
+ }
+ else
+ {
+ /* signed division */
+ mov2w(AOP(right),0);
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ mov2w(AOP(left),0);
+ call_libraryfunc("__modschar");
+ movwf(AOP(result),0);
+ }
- size = res->aop->size - 2;
- offset = 2;
- /* put zeros in the rest */
- while (size--)
- aopPut (res->aop, zero, offset++);
+ /* now we performed the signed/unsigned modulus -- extend result */
+ addSign(result, 1, sign);
}
-#if 0
/*-----------------------------------------------------------------*/
-/* opIsGptr: returns non-zero if the passed operand is */
-/* a generic pointer type. */
+/* genMod - generates code for division */
/*-----------------------------------------------------------------*/
-static int
-opIsGptr (operand * op)
+static void genMod (iCode *ic)
{
- sym_link *type = operandType (op);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if ((AOP_SIZE (op) == GPTRSIZE) && IS_GENPTR (type))
- {
- return 1;
- }
- return 0;
+ operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ operand *result= IC_RESULT(ic);
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ /* if both are of size == 1 */
+ if (AOP_SIZE(left) == 1 &&
+ AOP_SIZE(right) == 1 ) {
+ genModOneByte(left,right,result);
+ goto release ;
+ }
+
+ /* should have been converted to function call */
+ assert(0);
+
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
-#endif
/*-----------------------------------------------------------------*/
-/* getDataSize - get the operand data size */
+/* genIfxJump :- will create a jump depending on the ifx */
/*-----------------------------------------------------------------*/
-static int
-getDataSize (operand * op)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
-
- return AOP_SIZE (op);
+/*
+note: May need to add parameter to indicate when a variable is in bit space.
+*/
+static void genIfxJump (iCode *ic, char *jval)
+{
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if true label then we jump if condition
+ supplied is true */
+ if ( IC_TRUE(ic) ) {
+
+ if(strcmp(jval,"a") == 0)
+ emitSKPZ;
+ else if (strcmp(jval,"c") == 0)
+ emitSKPC;
+ else {
+ DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
+ emitpcode(POC_BTFSC, newpCodeOpBit(jval,-1,1));
+ }
+
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ic)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + labelOffset);
+
+ }
+ else {
+ /* false label is present */
+ if(strcmp(jval,"a") == 0)
+ emitSKPNZ;
+ else if (strcmp(jval,"c") == 0)
+ emitSKPNC;
+ else {
+ DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
+ emitpcode(POC_BTFSS, newpCodeOpBit(jval,-1,1));
+ }
+
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ic)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + labelOffset);
+
+ }
+
+
+ /* mark the icode as generated */
+ ic->generated = 1;
+}
- // tsd- in the pic port, the genptr size is 1, so this code here
- // fails. ( in the 8051 port, the size was 4).
#if 0
- int size;
- size = AOP_SIZE (op);
- if (size == GPTRSIZE)
- {
- sym_link *type = operandType (op);
- if (IS_GENPTR (type))
- {
- /* generic pointer; arithmetic operations
- * should ignore the high byte (pointer type).
- */
- size--;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
+/*-----------------------------------------------------------------*/
+/* genSkip */
+/*-----------------------------------------------------------------*/
+static void genSkip(iCode *ifx,int status_bit)
+{
+ FENTRY;
+ if(!ifx)
+ return;
+
+ if ( IC_TRUE(ifx) ) {
+ switch(status_bit) {
+ case 'z':
+ emitSKPNZ;
+ break;
+
+ case 'c':
+ emitSKPNC;
+ break;
+
+ case 'd':
+ emitSKPDC;
+ break;
+
+ }
+
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+
+ } else {
+
+ switch(status_bit) {
+
+ case 'z':
+ emitSKPZ;
+ break;
+
+ case 'c':
+ emitSKPC;
+ break;
+
+ case 'd':
+ emitSKPDC;
+ break;
+ }
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+
}
- }
- return size;
-#endif
+
}
+#endif
/*-----------------------------------------------------------------*/
-/* outAcc - output Acc */
+/* genSkipc */
/*-----------------------------------------------------------------*/
-static void
-outAcc (operand * result)
+static void genSkipc(resolvedIfx *rifx)
{
- int size, offset;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- size = getDataSize (result);
- if (size)
- {
- aopPut (AOP (result), "a", 0);
- size--;
- offset = 1;
- /* unsigned or positive */
- while (size--)
- {
- aopPut (AOP (result), zero, offset++);
- }
- }
+ FENTRY;
+ if(!rifx)
+ return;
+
+ if(rifx->condition)
+ emitSKPNC;
+ else
+ emitSKPC;
+
+ emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
+ emitpComment ("%s:%u: created from rifx:%p", __FUNCTION__, __LINE__, rifx);
+ rifx->generated = 1;
}
+#if 0
/*-----------------------------------------------------------------*/
-/* outBitC - output a bit C */
+/* genSkipz2 */
/*-----------------------------------------------------------------*/
-static void
-outBitC (operand * result)
+static void genSkipz2(resolvedIfx *rifx, int invert_condition)
{
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if the result is bit */
- if (AOP_TYPE (result) == AOP_CRY)
- aopPut (AOP (result), "c", 0);
- else
- {
- emitcode ("clr", "a ; %d", __LINE__);
- emitcode ("rlc", "a");
- outAcc (result);
- }
+ FENTRY;
+ if(!rifx)
+ return;
+
+ if( (rifx->condition ^ invert_condition) & 1)
+ emitSKPZ;
+ else
+ emitSKPNZ;
+
+ emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
+ rifx->generated = 1;
}
+#endif
+#if 0
/*-----------------------------------------------------------------*/
-/* toBoolean - emit code for orl a,operator(sizeop) */
+/* genSkipz */
/*-----------------------------------------------------------------*/
-static void
-toBoolean (operand * oper)
+static void genSkipz(iCode *ifx, int condition)
{
- int size = AOP_SIZE (oper) - 1;
- int offset = 1;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- if (AOP_TYPE (oper) != AOP_ACC)
- emitcode ("movf", "%s,w", aopGet (AOP (oper), 0, FALSE, FALSE));
-
- while (size--)
- emitcode ("iorwf", "%s,w", aopGet (AOP (oper), offset++, FALSE, FALSE));
+ FENTRY;
+ assert (ifx != NULL);
+
+ if(condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+
+ if ( IC_TRUE(ifx) )
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ else
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+
+ if ( IC_TRUE(ifx) )
+ pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ else
+ pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+
}
+#endif
-
+#if 0
/*-----------------------------------------------------------------*/
-/* genNot - generate code for ! operation */
+/* genSkipCond */
/*-----------------------------------------------------------------*/
-static void
-genNot (iCode * ic)
+static void genSkipCond(resolvedIfx *rifx,operand *op, int offset, int bit)
{
- symbol *tlbl;
- sym_link *optype = operandType (IC_LEFT (ic));
+ FENTRY;
+ if(!rifx)
+ return;
+
+ if(rifx->condition)
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
+ else
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
+
+
+ emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
+ rifx->generated = 1;
+}
+#endif
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* assign asmOps to operand & result */
- aopOp (IC_LEFT (ic), ic, FALSE);
- aopOp (IC_RESULT (ic), ic, TRUE);
+#if 0
+/*-----------------------------------------------------------------*/
+/* genChkZeroes :- greater or less than comparison */
+/* For each byte in a literal that is zero, inclusive or the */
+/* the corresponding byte in the operand with W */
+/* returns true if any of the bytes are zero */
+/*-----------------------------------------------------------------*/
+static int genChkZeroes(operand *op, int lit, int size)
+{
+
+ int i;
+ int flag =1;
+
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
+
+ if(i==0) {
+ if(flag)
+ emitpcode(POC_MOVFW, popGet(AOP(op),size));
+ else
+ emitpcode(POC_IORFW, popGet(AOP(op),size));
+ flag = 0;
+ }
+ }
+
+ return (flag==0);
+}
+#endif
- /* if in bit space then a special case */
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
- {
- emitcode ("movlw", "1<<%s");
- //emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir);
- //emitcode("cpl","c");
- //outBitC(IC_RESULT(ic));
- goto release;
- }
- /* if type float then do float */
- if (IS_FLOAT (optype))
- {
- genNotFloat (IC_LEFT (ic), IC_RESULT (ic));
- goto release;
- }
+#define isAOP_REGlike(x) (AOP_TYPE(x) == AOP_REG || AOP_TYPE(x) == AOP_DIR || AOP_TYPE(x) == AOP_PCODE)
+#define isAOP_LIT(x) (AOP_TYPE(x) == AOP_LIT)
+#define DEBUGpc emitpComment
- toBoolean (IC_LEFT (ic));
+/*-----------------------------------------------------------------*/
+/* mov2w_regOrLit :- move to WREG either the offset's byte from */
+/* aop (if it's NOT a literal) or from lit (if */
+/* aop is a literal) */
+/*-----------------------------------------------------------------*/
+void pic14_mov2w_regOrLit (asmop *aop, unsigned long lit, int offset) {
+ if (aop->type == AOP_LIT) {
+ emitpcode (POC_MOVLW, popGetLit((lit >> (offset*8)) & 0x00FF));
+ } else {
+ emitpcode (POC_MOVFW, popGet (aop, offset));
+ }
+}
- tlbl = newiTempLabel (NULL);
- emitcode ("cjne", "a,#0x01,%05d_DS_", tlbl->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- outBitC (IC_RESULT (ic));
+/* genCmp performs a left < right comparison, stores
+ * the outcome in result (if != NULL) and generates
+ * control flow code for the ifx (if != NULL).
+ *
+ * This version leaves in sequences like
+ * "B[CS]F STATUS,0; BTFS[CS] STATUS,0"
+ * which should be optmized by the peephole
+ * optimizer - RN 2005-01-01 */
+static void genCmp (operand *left,operand *right,
+ operand *result, iCode *ifx, int sign)
+{
+ resolvedIfx rIfx;
+ int size;
+ int offs;
+ symbol *templbl;
+ operand *dummy;
+ unsigned long lit;
+ unsigned long mask;
+ int performedLt;
+ int invert_result = 0;
+
+ FENTRY;
+
+ assert (AOP_SIZE(left) == AOP_SIZE(right));
+ assert (left && right);
+
+ size = AOP_SIZE(right) - 1;
+ mask = (0x100UL << (size*8)) - 1;
+ // in the end CARRY holds "left < right" (performedLt == 1) or "left >= right" (performedLt == 0)
+ performedLt = 1;
+ templbl = NULL;
+ lit = 0;
+
+ resolveIfx (&rIfx, ifx);
+
+ /**********************************************************************
+ * handle bits - bit compares are promoted to int compares seemingly! *
+ **********************************************************************/
+#if 0
+ // THIS IS COMPLETELY UNTESTED!
+ if (AOP_TYPE(left) == AOP_CRY && AOP_TYPE(right) == AOP_CRY) {
+ pCodeOp *pcleft = pic16_popGet(AOP(left), 0);
+ pCodeOp *pcright = pic16_popGet(AOP(right), 0);
+ assert (pcleft->type == PO_GPR_BIT && pcright->type == PO_GPR_BIT);
+
+ emitSETC;
+ // 1 < {0,1} is false --> clear C by skipping the next instruction
+ //pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (AOP(left),0), PCORB(pcleft)->bit);
+ pic16_emitpcode (POC_BTFSS, pic16_popGet (AOP(left), 0));
+ // {0,1} < 0 is false --> clear C by NOT skipping the next instruction
+ pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (pic16_popGet(AOP(right),0), PCORB(pcright)->bit));
+ emitCLRC; // only skipped for left=0 && right=1
+
+ goto correct_result_in_carry;
+ } // if
+#endif
-release:
- /* release the aops */
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ /*************************************************
+ * make sure that left is register (or the like) *
+ *************************************************/
+ if (!isAOP_REGlike(left)) {
+ DEBUGpc ("swapping arguments (AOP_TYPEs %d/%d)", AOP_TYPE(left), AOP_TYPE(right));
+ assert (isAOP_LIT(left));
+ assert (isAOP_REGlike(right));
+ // swap left and right
+ // left < right <==> right > left <==> (right >= left + 1)
+ lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
+
+ if ( (!sign && (lit & mask) == mask) || (sign && (lit & mask) == (mask >> 1)) ) {
+ // MAXVALUE < right? always false
+ if (performedLt) emitCLRC; else emitSETC;
+ goto correct_result_in_carry;
+ } // if
+
+ // This fails for lit = 0xFF (unsigned) AND lit = 0x7F (signed),
+ // that's why we handled it above.
+ lit++;
+
+ dummy = left;
+ left = right;
+ right = dummy;
+
+ performedLt ^= 1; // instead of "left < right" we check for "right >= left+1, i.e. "right < left+1"
+ } else if (isAOP_LIT(right)) {
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+ } // if
+
+ assert (isAOP_REGlike(left)); // left must be register or the like
+ assert (isAOP_REGlike(right) || isAOP_LIT(right)); // right may be register-like or a literal
+
+ /*************************************************
+ * special cases go here *
+ *************************************************/
+
+ if (isAOP_LIT(right)) {
+ if (!sign) {
+ // unsigned comparison to a literal
+ DEBUGpc ("unsigned compare: left %s lit(0x%X=%lu), size=%d", performedLt ? "<" : ">=", lit, lit, size+1);
+ if (lit == 0) {
+ // unsigned left < 0? always false
+ if (performedLt) emitCLRC; else emitSETC;
+ goto correct_result_in_carry;
+ }
+ } else {
+ // signed comparison to a literal
+ DEBUGpc ("signed compare: left %s lit(0x%X=%ld), size=%d, mask=%x", performedLt ? "<" : ">=", lit, lit, size+1, mask);
+ if ((lit & mask) == ((0x80 << (size*8)) & mask)) {
+ // signed left < 0x80000000? always false
+ if (performedLt) emitCLRC; else emitSETC;
+ goto correct_result_in_carry;
+ } else if (lit == 0) {
+ // compare left < 0; set CARRY if SIGNBIT(left) is set
+ if (performedLt) emitSETC; else emitCLRC;
+ emitpcode (POC_BTFSS, newpCodeOpBit (aopGet (AOP(left), size, FALSE, FALSE), 7, 0));
+ if (performedLt) emitCLRC; else emitSETC;
+ goto correct_result_in_carry;
+ }
+ } // if (!sign)
+ } // right is literal
+
+ /*************************************************
+ * perform a general case comparison *
+ * make sure we get CARRY==1 <==> left >= right *
+ *************************************************/
+ // compare most significant bytes
+ //DEBUGpc ("comparing bytes at offset %d", size);
+ if (!sign) {
+ // unsigned comparison
+ pic14_mov2w_regOrLit (AOP(right), lit, size);
+ emitpcode (POC_SUBFW, popGet (AOP(left), size));
+ } else {
+ // signed comparison
+ // (add 2^n to both operands then perform an unsigned comparison)
+ if (isAOP_LIT(right)) {
+ // left >= LIT <-> LIT-left <= 0 <-> LIT-left == 0 OR !(LIT-left >= 0)
+ unsigned char litbyte = (lit >> (8*size)) & 0xFF;
+
+ if (litbyte == 0x80) {
+ // left >= 0x80 -- always true, but more bytes to come
+ mov2w (AOP(left), size);
+ emitpcode (POC_XORLW, popGetLit (0x80)); // set ZERO flag
+ emitSETC;
+ } else {
+ // left >= LIT <-> left + (-LIT) >= 0 <-> left + (0x100-LIT) >= 0x100
+ mov2w (AOP(left), size);
+ emitpcode (POC_ADDLW, popGetLit (0x80));
+ emitpcode (POC_ADDLW, popGetLit ((0x100 - (litbyte + 0x80)) & 0x00FF));
+ } // if
+ } else {
+ pCodeOp *pctemp = popGetTempReg();
+ mov2w (AOP(left), size);
+ emitpcode (POC_ADDLW, popGetLit (0x80));
+ emitpcode (POC_MOVWF, pctemp);
+ mov2w (AOP(right), size);
+ emitpcode (POC_ADDLW, popGetLit (0x80));
+ emitpcode (POC_SUBFW, pctemp);
+ popReleaseTempReg(pctemp);
+ }
+ } // if (!sign)
+
+ // compare remaining bytes (treat as unsigned case from above)
+ templbl = newiTempLabel ( NULL );
+ offs = size;
+ while (offs--) {
+ //DEBUGpc ("comparing bytes at offset %d", offs);
+ emitSKPZ;
+ emitpcode (POC_GOTO, popGetLabel (templbl->key));
+ pic14_mov2w_regOrLit (AOP(right), lit, offs);
+ emitpcode (POC_SUBFW, popGet (AOP(left), offs));
+ } // while (offs)
+ emitpLabel (templbl->key);
+ goto result_in_carry;
+
+result_in_carry:
+
+ /****************************************************
+ * now CARRY contains the result of the comparison: *
+ * SUBWF sets CARRY iff *
+ * F-W >= 0 <==> F >= W <==> !(F < W) *
+ * (F=left, W=right) *
+ ****************************************************/
+
+ if (performedLt) {
+ invert_result = 1;
+ // value will be used in the following genSkipc()
+ rIfx.condition ^= 1;
+ } // if
+
+correct_result_in_carry:
+
+ // assign result to variable (if neccessary)
+ if (result && AOP_TYPE(result) != AOP_CRY) {
+ //DEBUGpc ("assign result");
+ size = AOP_SIZE(result);
+ while (size--) {
+ emitpcode (POC_CLRF, popGet (AOP(result), size));
+ } // while
+ if (invert_result) {
+ emitSKPC;
+ emitpcode (POC_BSF, newpCodeOpBit (aopGet (AOP(result), 0, FALSE, FALSE), 0, 0));
+ } else {
+ emitpcode (POC_RLF, popGet (AOP(result), 0));
+ }
+ } // if (result)
+
+ // perform conditional jump
+ if (ifx) {
+ //DEBUGpc ("generate control flow");
+ genSkipc (&rIfx);
+ ifx->generated = 1;
+ } // if
}
+#if 0
+/* OLD VERSION -- BUGGY, DO NOT USE */
+
/*-----------------------------------------------------------------*/
-/* genCpl - generate code for complement */
+/* genCmp :- greater or less than comparison */
/*-----------------------------------------------------------------*/
-static void
-genCpl (iCode * ic)
-{
- int offset = 0;
- int size;
+static void genCmp (operand *left,operand *right,
+ operand *result, iCode *ifx, int sign)
+{
+ int size; //, offset = 0 ;
+ unsigned long lit = 0L,i = 0;
+ resolvedIfx rFalseIfx;
+ // resolvedIfx rTrueIfx;
+ symbol *truelbl;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /*
+ if(ifx) {
+ DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
+ DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
+ }
+ */
+
+ resolveIfx(&rFalseIfx,ifx);
+ truelbl = newiTempLabel(NULL);
+ size = max(AOP_SIZE(left),AOP_SIZE(right));
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+#define _swapp
+
+ /* if literal is on the right then swap with left */
+ if ((AOP_TYPE(right) == AOP_LIT)) {
+ operand *tmp = right ;
+ unsigned long mask = (0x100 << (8*(size-1))) - 1;
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+#ifdef _swapp
+
+ lit = (lit - 1) & mask;
+ right = left;
+ left = tmp;
+ rFalseIfx.condition ^= 1;
+#endif
+
+ } else if ((AOP_TYPE(left) == AOP_LIT)) {
+ lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
+ }
+
+
+ //if(IC_TRUE(ifx) == NULL)
+ /* if left & right are bit variables */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right) == AOP_CRY ) {
+ pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+ pic14_emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
+ } else {
+ /* subtract right from left if at the
+ end the carry flag is set then we know that
+ left is greater than right */
+
+ symbol *lbl = newiTempLabel(NULL);
+
+#ifndef _swapp
+ if(AOP_TYPE(right) == AOP_LIT) {
+
+ //lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
+
+ /* special cases */
+
+ if(lit == 0) {
+
+ if(sign != 0)
+ genSkipCond(&rFalseIfx,left,size-1,7);
+ else
+ /* no need to compare to 0...*/
+ /* NOTE: this is a de-generate compare that most certainly
+ * creates some dead code. */
+ emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+ size--;
+
+ if(size == 0) {
+ //i = (lit >> (size*8)) & 0xff;
+ DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+
+ i = ((0-lit) & 0xff);
+ if(sign) {
+ if( i == 0x81) {
+ /* lit is 0x7f, all signed chars are less than
+ * this except for 0x7f itself */
+ emitpcode(POC_XORLW, popGetLit(0x7f));
+ genSkipz2(&rFalseIfx,0);
+ } else {
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+ emitpcode(POC_ADDLW, popGetLit(i^0x80));
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ }
+
+ } else {
+ if(lit == 1) {
+ genSkipz2(&rFalseIfx,1);
+ } else {
+ emitpcode(POC_ADDLW, popGetLit(i));
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ }
+ }
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ /* chars are out of the way. now do ints and longs */
+
+
+ DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+
+ /* special cases */
+
+ if(sign) {
+
+ if(lit == 0) {
+ genSkipCond(&rFalseIfx,left,size,7);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(lit <0x100) {
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,left,size,7);
+ //rFalseIfx.condition ^= 1;
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ emitpcode(POC_MOVLW, popGetLit(0x100-lit));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),1));
+
+ while(size > 1)
+ emitpcode(POC_IORFW, popGet(AOP(left),size--));
+
+ if(rFalseIfx.condition) {
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ } else {
+ emitSKPNZ;
+ }
+
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ emitpLabel(truelbl->key);
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+
+ if(size == 1) {
+
+ if( (lit & 0xff) == 0) {
+ /* lower byte is zero */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ i = ((lit >> 8) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+ } else {
+ /* Special cases for signed longs */
+ if( (lit & 0xffffff) == 0) {
+ /* lower byte is zero */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ i = ((lit >> 8*3) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+
+ }
+
+
+ if(lit & (0x80 << (size*8))) {
+ /* lit is negative */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+
+ //genSkipCond(&rFalseIfx,left,size,7);
+
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+
+
+ } else {
+ /* lit is positive */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ }
+
+ /* There are no more special cases, so perform a general compare */
+
+ emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+
+ while(size--) {
+
+ emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ }
+ //rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+
+ emitpLabel(truelbl->key);
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+
+ }
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* assign asmOps to operand & result */
- aopOp (IC_LEFT (ic), ic, FALSE);
- aopOp (IC_RESULT (ic), ic, TRUE);
+ /* sign is out of the way. So now do an unsigned compare */
+ DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
+
+
+ /* General case - compare to an unsigned literal on the right.*/
+
+ i = (lit >> (size*8)) & 0xff;
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
+
+ if(i) {
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ } else {
+ /* this byte of the lit is zero,
+ *if it's not the last then OR in the variable */
+ if(size)
+ emitpcode(POC_IORFW, popGet(AOP(left),size));
+ }
+ }
- /* 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)
- {
- 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;
- }
+ emitpLabel(lbl->key);
+ //if(emitFinalCheck)
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ if(sign)
+ emitpLabel(truelbl->key);
- size = AOP_SIZE (IC_RESULT (ic));
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("cpl", "a");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
- }
+ if(ifx) ifx->generated = 1;
+ return;
-release:
- /* release the aops */
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ }
+#endif // _swapp
+
+ if(AOP_TYPE(left) == AOP_LIT) {
+ //symbol *lbl = newiTempLabel(NULL);
+
+ //EXPERIMENTAL lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
+
+
+ DEBUGpic14_emitcode(";left lit","lit = 0x%x,sign=%d",lit,sign);
+
+ /* Special cases */
+ if((lit == 0) && (sign == 0)){
+
+ size--;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size)
+ emitpcode(POC_IORFW, popGet(AOP(right),--size));
+
+ genSkipz2(&rFalseIfx,0);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(size==1) {
+ /* Special cases */
+ lit &= 0xff;
+ if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
+ /* degenerate compare can never be true */
+ if(rFalseIfx.condition == 0)
+ emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(sign) {
+ /* signed comparisons to a literal byte */
+
+ int lp1 = (lit+1) & 0xff;
+
+ DEBUGpic14_emitcode(";left lit","line = %d lit = 0x%x",__LINE__,lit);
+ switch (lp1) {
+ case 0:
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,0,7);
+ break;
+ case 0x7f:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_XORLW, popGetLit(0x7f));
+ genSkipz2(&rFalseIfx,1);
+ break;
+ default:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+ emitpcode(POC_ADDLW, popGetLit(((0-(lit+1)) & 0xff) ^ 0x80));
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ break;
+ }
+ if(ifx) ifx->generated = 1;
+ } else {
+ /* unsigned comparisons to a literal byte */
+
+ switch(lit & 0xff ) {
+ case 0:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ genSkipz2(&rFalseIfx,0);
+ if(ifx) ifx->generated = 1;
+ break;
+ case 0x7f:
+ genSkipCond(&rFalseIfx,right,0,7);
+ if(ifx) ifx->generated = 1;
+ break;
+
+ default:
+ emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ rFalseIfx.condition ^= 1;
+ if (AOP_TYPE(result) == AOP_CRY) {
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ if(ifx) ifx->generated = 1;
+ } else {
+ DEBUGpic14_emitcode ("; ***","%s %d RFIfx.cond=%d",__FUNCTION__,__LINE__, rFalseIfx.condition);
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW, popGetLit(0x01));
+ emitpcode(POC_XORWF, popGet(AOP(result),0));
+ }
+ break;
+ }
+ }
+
+ //goto check_carry;
+ return;
+
+ } else {
+
+ /* Size is greater than 1 */
+
+ if(sign) {
+ int lp1 = lit+1;
+
+ size--;
+
+ if(lp1 == 0) {
+ /* this means lit = 0xffffffff, or -1 */
+
+
+ DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,size,7);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(lit == 0) {
+ int s = size;
+
+ if(rFalseIfx.condition) {
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ }
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size--)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+
+
+ emitSKPZ;
+ if(rFalseIfx.condition) {
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ emitpLabel(truelbl->key);
+ }else {
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,s,7);
+ }
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if((size == 1) && (0 == (lp1&0xff))) {
+ /* lower byte of signed word is zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x+1 low byte is zero",__LINE__,lit);
+ i = ((lp1 >> 8) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(lit & (0x80 << (size*8))) {
+ /* Lit is less than zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x is less than 0",__LINE__,lit);
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,left,size,7);
+ //rFalseIfx.condition ^= 1;
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ //emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+
+ } else {
+ /* Lit is greater than or equal to zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x is greater than 0",__LINE__,lit);
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,right,size,7);
+ //rFalseIfx.condition ^= 1;
+
+ //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ //emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+
+ }
+
+
+ emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+ while(size--) {
+
+ emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ }
+ rFalseIfx.condition ^= 1;
+ //rFalseIfx.condition = 1;
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+
+ emitpLabel(truelbl->key);
+
+ if(ifx) ifx->generated = 1;
+ return;
+ // end of if (sign)
+ } else {
+
+ /* compare word or long to an unsigned literal on the right.*/
+
+
+ size--;
+ if(lit < 0xff) {
+ DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x < 0xff",__FUNCTION__,__LINE__,lit);
+ switch (lit) {
+ case 0:
+ break; /* handled above */
+ /*
+ case 0xff:
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size--)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+ genSkipz2(&rFalseIfx,0);
+ break;
+ */
+ default:
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(--size)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+
+ emitSKPZ;
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+
+ emitpcode(POC_MOVLW, popGetLit(lit+1));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
+
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ }
+
+ emitpLabel(truelbl->key);
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+
+ lit++;
+ DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x",__FUNCTION__,__LINE__,lit);
+ i = (lit >> (size*8)) & 0xff;
+
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
+
+ if(i) {
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ } else {
+ /* this byte of the lit is zero,
+ *if it's not the last then OR in the variable */
+ if(size)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+ }
+ }
+
+
+ emitpLabel(lbl->key);
+
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ }
+
+ if(sign)
+ emitpLabel(truelbl->key);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+ }
+ /* Compare two variables */
+
+ DEBUGpic14_emitcode(";sign","%d",sign);
+
+ size--;
+ if(sign) {
+ /* Sigh. thus sucks... */
+ if(size) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ emitpcode(POC_MOVLW, popGetLit(0x80));
+ emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
+ emitpcode(POC_XORFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
+ } else {
+ /* Signed char comparison */
+ /* Special thanks to Nikolai Golovchenko for this snippet */
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_SUBFW, popGet(AOP(left),0));
+ emitpcode(POC_RRFW, popGet(AOP(left),0)); /* could be any register */
+ emitpcode(POC_XORFW, popGet(AOP(left),0));
+ emitpcode(POC_XORFW, popGet(AOP(right),0));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ } else {
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ }
+
+
+ /* The rest of the bytes of a multi-byte compare */
+ while (size) {
+
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(lbl->key));
+ size--;
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+
+
+ }
+
+ emitpLabel(lbl->key);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) ||
+ (AOP_TYPE(result) == AOP_REG)) {
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ } else {
+ genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ }
+ //genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
+ if(ifx) ifx->generated = 1;
+
+ return;
+
+ }
+
+ // check_carry:
+ if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ pic14_outBitC(result);
+ } else {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if the result is used in the next
+ ifx conditional branch then generate
+ code a little differently */
+ if (ifx )
+ genIfxJump (ifx,"c");
+ else
+ pic14_outBitC(result);
+ /* leave the result in acc */
+ }
+
}
+#endif
/*-----------------------------------------------------------------*/
-/* genUminusFloat - unary minus for floating points */
+/* genCmpGt :- greater than comparison */
/*-----------------------------------------------------------------*/
-static void
-genUminusFloat (operand * op, operand * result)
-{
- int size, offset = 0;
- char *l;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* for this we just need to flip the
- first it then copy the rest in place */
- size = AOP_SIZE (op) - 1;
- l = aopGet (AOP (op), 3, FALSE, FALSE);
-
- MOVA (l);
-
- emitcode ("cpl", "acc.7");
- aopPut (AOP (result), "a", 3);
+static void genCmpGt (iCode *ic, iCode *ifx)
+{
+ operand *left, *right, *result;
+ sym_link *letype , *retype;
+ int sign ;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ left = IC_LEFT(ic);
+ right= IC_RIGHT(ic);
+ result = IC_RESULT(ic);
+
+ letype = getSpec(operandType(left));
+ retype =getSpec(operandType(right));
+ sign = !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ genCmp(right, left, result, ifx, sign);
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
- while (size--)
- {
- aopPut (AOP (result),
- aopGet (AOP (op), offset, FALSE, FALSE),
- offset);
- offset++;
- }
+/*-----------------------------------------------------------------*/
+/* genCmpLt - less than comparisons */
+/*-----------------------------------------------------------------*/
+static void genCmpLt (iCode *ic, iCode *ifx)
+{
+ operand *left, *right, *result;
+ sym_link *letype , *retype;
+ int sign ;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ left = IC_LEFT(ic);
+ right= IC_RIGHT(ic);
+ result = IC_RESULT(ic);
+
+ letype = getSpec(operandType(left));
+ retype =getSpec(operandType(right));
+ sign = !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
+
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ genCmp(left, right, result, ifx, sign);
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
+#if 0
/*-----------------------------------------------------------------*/
-/* genUminus - unary minus code generation */
+/* genc16bit2lit - compare a 16 bit value to a literal */
/*-----------------------------------------------------------------*/
-static void
-genUminus (iCode * ic)
+static void genc16bit2lit(operand *op, int lit, int offset)
{
- int offset, size;
- sym_link *optype, *rtype;
-
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* assign asmops */
- aopOp (IC_LEFT (ic), ic, FALSE);
- aopOp (IC_RESULT (ic), ic, TRUE);
-
- /* if both in bit space then special
- case */
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY &&
- 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;
- }
-
- optype = operandType (IC_LEFT (ic));
- rtype = operandType (IC_RESULT (ic));
-
- /* if float then do float stuff */
- if (IS_FLOAT (optype))
- {
- genUminusFloat (IC_LEFT (ic), IC_RESULT (ic));
- goto release;
- }
-
- /* otherwise subtract from zero */
- size = AOP_SIZE (IC_LEFT (ic));
- offset = 0;
- CLRC;
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
- if (!strcmp (l, "a"))
- {
- emitcode ("cpl", "a");
- emitcode ("inc", "a");
- }
- else
- {
- emitcode ("clr", "a");
- emitcode ("subb", "a,%s", l);
+ int i;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d, lit = %d",__FUNCTION__,__LINE__,lit);
+ if( (lit&0xff) == 0)
+ i=1;
+ else
+ i=0;
+
+ switch( BYTEofLONG(lit,i)) {
+ case 0:
+ emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
+ break;
+ case 1:
+ emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
+ break;
+ case 0xff:
+ emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
+ break;
+ default:
+ emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
+ emitpcode(POC_XORLW,popGetLit(BYTEofLONG(lit,i)));
+ }
+
+ i ^= 1;
+
+ switch( BYTEofLONG(lit,i)) {
+ case 0:
+ emitpcode(POC_IORFW,popGet(AOP(op),offset+i));
+ break;
+ case 1:
+ emitSKPNZ;
+ emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
+ break;
+ case 0xff:
+ emitSKPNZ;
+ emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
+ break;
+ default:
+ emitpcode(POC_MOVLW,popGetLit(BYTEofLONG(lit,i)));
+ emitSKPNZ;
+ emitpcode(POC_XORFW,popGet(AOP(op),offset+i));
+
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
- }
-
- /* if any remaining bytes in the result */
- /* we just need to propagate the sign */
- if ((size = (AOP_SIZE (IC_RESULT (ic)) - AOP_SIZE (IC_LEFT (ic)))))
- {
- emitcode ("rlc", "a");
- emitcode ("subb", "a,acc");
- while (size--)
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
- }
-
-release:
- /* release the aops */
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+
}
+#endif
+#if 0
/*-----------------------------------------------------------------*/
-/* saveRegisters - will look for a call and save the registers */
+/* gencjneshort - compare and jump if not equal */
/*-----------------------------------------------------------------*/
-static void
-saveRegisters (iCode * lic)
-{
- int i;
- iCode *ic;
- bitVect *rsave;
- sym_link *detype;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* look for call */
- for (ic = lic; ic; ic = ic->next)
- if (ic->op == CALL || ic->op == PCALL)
- break;
-
- if (!ic)
- {
- fprintf (stderr, "found parameter push with no function call\n");
- return;
- }
-
- /* if the registers have been saved already then
- do nothing */
- if (ic->regsSaved || (OP_SYMBOL (IC_LEFT (ic))->calleeSave))
- return;
-
- /* find the registers in use at this time
- and push them away to safety */
- rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
- ic->rUsed);
-
- ic->regsSaved = 1;
- if (options.useXstack)
- {
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "b,r0");
- emitcode ("mov", "r0,%s", spname);
- for (i = 0; i < pic14_nRegs; i++)
+static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
+{
+ int size = min(AOP_SIZE(left),AOP_SIZE(right));
+ int offset = 0;
+ //resolvedIfx rIfx;
+ symbol *lbl;
+
+ //unsigned long lit = 0L;
+ FENTRY;
+ if (!ifx && (!result || AOP_TYPE(result) == AOP_CRY)) {
+ emitpComment ("gencjne: no ifx, no (real) result -- comparison ignored");
+ return;
+ }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ assert (!pic14_sameRegs (AOP(left), AOP(result)));
+ assert (!pic14_sameRegs (AOP(right), AOP(result)));
+ if (AOP_SIZE(result)) {
+ for (offset = 0; offset < AOP_SIZE(result); offset++)
+ emitpcode (POC_CLRF, popGet (AOP(result), offset));
+ }
+
+ assert (AOP_SIZE(left) == AOP_SIZE(right));
+ //resolveIfx(&rIfx,ifx);
+ lbl = newiTempLabel (NULL);
+ while (size--)
{
- if (bitVectBitValue (rsave, i))
- {
- if (i == R0_IDX)
- emitcode ("mov", "a,b");
- else
- emitcode ("mov", "a,%s", pic14_regWithIdx (i)->name);
- emitcode ("movx", "@r0,a");
- emitcode ("inc", "r0");
- }
+ mov2w (AOP(right),size);
+ emitpcode (POC_XORFW, popGet (AOP(left), size));
+ if (size)
+ {
+ emitSKPZ;
+ emitpcode (POC_GOTO, popGetLabel (lbl->key));
+ }
+ } // while
+ emitpLabel (lbl->key);
+ if (AOP_SIZE(result)) {
+ emitSKPNZ;
+ emitpcode (POC_INCF, popGet (AOP(result), 0));
+ } else {
+ assert (ifx);
+ genSkipz (ifx, NULL != IC_TRUE(ifx));
+ ifx->generated = 1;
}
- emitcode ("mov", "%s,r0", spname);
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "r0,b");
- }
- else
- for (i = 0; i < pic14_nRegs; i++)
- {
- if (bitVectBitValue (rsave, i))
- emitcode ("push", "%s", pic14_regWithIdx (i)->dname);
- }
-
- detype = getSpec (operandType (IC_LEFT (ic)));
- if (detype &&
- (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
- IS_ISR (currFunc->etype) &&
- !ic->bankSaved)
-
- saverbank (SPEC_BANK (detype), ic, TRUE);
-
-}
-/*-----------------------------------------------------------------*/
-/* unsaveRegisters - pop the pushed registers */
-/*-----------------------------------------------------------------*/
-static void
-unsaveRegisters (iCode * ic)
-{
- int i;
- bitVect *rsave;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* 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 = pic14_nRegs; i >= 0; i--)
+ return;
+#if 0
+ if(result)
{
- if (bitVectBitValue (rsave, i))
- {
- emitcode ("dec", "r0");
- emitcode ("movx", "a,@r0");
- if (i == R0_IDX)
- emitcode ("mov", "b,a");
- else
- emitcode ("mov", "%s,a", pic14_regWithIdx (i)->name);
- }
-
+ DEBUGpic14_emitcode ("; ***","%s %d result is not null",__FUNCTION__,__LINE__);
+ assert (!pic14_sameRegs (AOP(result), AOP(left)));
+ assert (!pic14_sameRegs (AOP(result), AOP(right)));
+ for (offset=0; offset < AOP_SIZE(result); offset++)
+ {
+ emitpcode (POC_CLRF, popGet (AOP(result), offset));
+ } // for offset
+ }
+
+
+ /* if the left side is a literal or
+ if the right is in a pointer register and left
+ is not */
+ if ((AOP_TYPE(left) == AOP_LIT) ||
+ (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
+ operand *t = right;
+ right = left;
+ left = t;
+ }
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ /* if the right side is a literal then anything goes */
+ if (AOP_TYPE(right) == AOP_LIT &&
+ AOP_TYPE(left) != AOP_DIR ) {
+ switch(size) {
+ case 2:
+ genc16bit2lit(left, lit, 0);
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ break;
+ default:
+ offset = 0;
+ while (size--) {
+ if(lit & 0xff) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+ } else {
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
+ }
+
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ offset++;
+ lit >>= 8;
+ }
+ break;
+ }
}
- emitcode ("mov", "%s,r0", spname);
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "r0,b");
- }
- else
- for (i = pic14_nRegs; i >= 0; i--)
- {
- if (bitVectBitValue (rsave, i))
- emitcode ("pop", "%s", pic14_regWithIdx (i)->dname);
- }
-
+
+ /* if the right side is in a register or in direct space or
+ if the left is a pointer register & right is not */
+ else if (AOP_TYPE(right) == AOP_REG ||
+ AOP_TYPE(right) == AOP_DIR ||
+ (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
+ (IS_AOP_PREG(left) && !IS_AOP_PREG(right))) {
+ //int lbl_key = (rIfx.condition) ? rIfx.lbl->key : lbl->key;
+ int lbl_key = lbl->key;
+
+ if(!result) {
+ DEBUGpic14_emitcode ("; ***","%s %d -- ERROR",__FUNCTION__,__LINE__);
+ fprintf(stderr, "%s %d error - expecting result to be non_null\n",
+ __FUNCTION__,__LINE__);
+ return;
+ }
+
+ /* switch(size) { */
+ /* case 2: */
+ /* genc16bit2lit(left, lit, 0); */
+ /* emitSKPNZ; */
+ /* emitpcode(POC_GOTO,popGetLabel(lbl->key)); */
+ /* break; */
+ /* default: */
+ offset = 0;
+ while (size--) {
+ int emit_skip=1;
+ if((AOP_TYPE(left) == AOP_DIR) &&
+ ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+
+ } else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
+
+ switch (lit & 0xff) {
+ case 0:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ break;
+ case 1:
+ emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ emit_skip=0;
+ break;
+ case 0xff:
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_GOTO,popGetLabel(lbl_key));
+ emit_skip=0;
+ break;
+ default:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+ }
+ lit >>= 8;
+
+ } else {
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
+ }
+ if(emit_skip) {
+ if(AOP_TYPE(result) == AOP_CRY) {
+ pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
+ if(rIfx.condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+ } else {
+ /* fix me. probably need to check result size too */
+ //emitpcode(POC_CLRF,popGet(AOP(result),0));
+ if(rIfx.condition)
+ emitSKPZ;
+ else
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl_key));
+ }
+ if(ifx)
+ ifx->generated=1;
+ }
+ emit_skip++;
+ offset++;
+ }
+ /* break; */
+ /* } */
+ } else if(AOP_TYPE(right) == AOP_REG &&
+ AOP_TYPE(left) != AOP_DIR){
+
+ offset = 0;
+ while(size--) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+ pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
+ if(rIfx.condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+ offset++;
+ }
+
+ }else{
+ /* right is a pointer reg need both a & b */
+ offset = 0;
+ while(size--) {
+ char *l = aopGet(AOP(left),offset,FALSE,FALSE);
+ if(strcmp(l,"b"))
+ pic14_emitcode("mov","b,%s",l);
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("cjne","a,b,%05d_DS_",lbl->key+100);
+ offset++;
+ }
+ }
+
+ emitpcode(POC_INCF,popGet(AOP(result),0));
+ if(!rIfx.condition)
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+
+ emitpLabel(lbl->key);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(ifx)
+ ifx->generated = 1;
+#endif
}
+#endif
-
+#if 0
/*-----------------------------------------------------------------*/
-/* pushSide - */
+/* gencjne - compare and jump if not equal */
/*-----------------------------------------------------------------*/
-static void
-pushSide (operand * oper, int size)
-{
- int offset = 0;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- while (size--)
- {
- char *l = aopGet (AOP (oper), offset++, FALSE, TRUE);
- if (AOP_TYPE (oper) != AOP_REG &&
- AOP_TYPE (oper) != AOP_DIR &&
- strcmp (l, "a"))
- {
- emitcode ("mov", "a,%s", l);
- emitcode ("push", "acc");
- }
- else
- emitcode ("push", "%s", l);
- }
+static void gencjne(operand *left, operand *right, iCode *ifx)
+{
+ symbol *tlbl = newiTempLabel(NULL);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ gencjneshort(left, right, lbl);
+
+ pic14_emitcode("mov","a,%s",one);
+ pic14_emitcode("sjmp","%05d_DS_",tlbl->key+100);
+ pic14_emitcode("","%05d_DS_:",lbl->key+100);
+ pic14_emitcode("clr","a");
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+
+ emitpLabel(lbl->key);
+ emitpLabel(tlbl->key);
+
}
+#endif
/*-----------------------------------------------------------------*/
-/* assignResultValue - */
+/* genCmpEq - generates code for equal to */
/*-----------------------------------------------------------------*/
-static void
-assignResultValue (operand * oper)
+static void genCmpEq (iCode *ic, iCode *ifx)
{
- int offset = 0;
- int size = AOP_SIZE (oper);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- // The last byte in the assignment is in W
- aopPut (AOP (oper), "W", size - 1);
+ operand *left, *right, *result;
+ int size;
+ symbol *false_label;
- if (size > 1)
- {
- while (--size)
- {
- aopPut (AOP (oper), fReturn[offset], offset);
- offset++;
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- }
- }
-}
+ if(ifx)
+ DEBUGpic14_emitcode ("; ifx is non-null","");
+ else
+ DEBUGpic14_emitcode ("; ifx is null","");
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
-/*-----------------------------------------------------------------*/
-/* genXpush - pushes onto the external stack */
-/*-----------------------------------------------------------------*/
-static void
-genXpush (iCode * ic)
-{
- asmop *aop = newAsmop (0);
- regs *r;
- int size, offset = 0;
+ DEBUGpic14_AopType(__LINE__,left,right,result);
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp (IC_LEFT (ic), ic, FALSE);
- r = getFreePtr (ic, &aop, FALSE);
+ /* if literal, move literal to right */
+ if (op_isLitLike (IC_LEFT(ic))) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+ false_label = NULL;
+ if (ifx && !IC_TRUE(ifx))
+ {
+ assert (IC_FALSE(ifx));
+ false_label = IC_FALSE(ifx);
+ }
- emitcode ("mov", "%s,_spx", r->name);
+ size = min(AOP_SIZE(left),AOP_SIZE(right));
+ assert(!pic14_sameRegs(AOP(result),AOP(left)));
+ assert(!pic14_sameRegs(AOP(result),AOP(right)));
- size = AOP_SIZE (IC_LEFT (ic));
- while (size--)
+ /* assume left != right */
+ {
+ int i;
+ for (i=0; i < AOP_SIZE(result); i++)
{
-
- char *l = aopGet (AOP (IC_LEFT (ic)),
- offset++, FALSE, FALSE);
- MOVA (l);
- emitcode ("movx", "@%s,a", r->name);
- emitcode ("inc", "%s", r->name);
-
+ emitpcode(POC_CLRF, popGet(AOP(result),i));
}
+ }
+ if (AOP_TYPE(right) == AOP_LIT)
+ {
+ unsigned long lit = (unsigned long) floatFromVal (AOP(right)->aopu.aop_lit);
+ int i;
+ size = AOP_SIZE(left);
+ assert(!op_isLitLike(left));
+
+ switch (lit)
+ {
+ case 0:
+ mov2w(AOP(left), 0);
+ for (i=1; i < size; i++)
+ emitpcode(POC_IORFW,popGet(AOP(left),i));
+ /* now Z is set iff `left == right' */
+ emitSKPZ;
+ if (!false_label) false_label = newiTempLabel(NULL);
+ emitpcode(POC_GOTO, popGetLabel(false_label->key));
+ break;
- emitcode ("mov", "_spx,%s", r->name);
-
- freeAsmop (NULL, aop, ic, TRUE);
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genIpush - genrate code for pushing this gets a little complex */
-/*-----------------------------------------------------------------*/
-static void
-genIpush (iCode * ic)
-{
- int size, offset = 0;
- char *l;
-
+ default:
+ for (i=0; i < size; i++)
+ {
+ mov2w(AOP(left),i);
+ emitpcode(POC_XORLW, popGetLit(lit >> (8*i)));
+ /* now Z is cleared if `left != right' */
+ emitSKPZ;
+ if (!false_label) false_label = newiTempLabel(NULL);
+ emitpcode(POC_GOTO, popGetLabel(false_label->key));
+ } // for i
+ break;
+ } // switch (lit)
+ }
+ else
+ {
+ /* right is no literal */
+ int i;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if this is not a parm push : ie. it is spill push
- and spill push is always done on the local stack */
- if (!ic->parmPush)
+ for (i=0; i < size; i++)
{
+ mov2w(AOP(right),i);
+ emitpcode(POC_XORFW,popGet(AOP(left),i));
+ /* now Z is cleared if `left != right' */
+ emitSKPZ;
+ if (!false_label) false_label = newiTempLabel(NULL);
+ emitpcode(POC_GOTO, popGetLabel(false_label->key));
+ } // for i
+ }
- /* and the item is spilt then do nothing */
- if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
- return;
+ /* if we reach here, left == right */
- aopOp (IC_LEFT (ic), ic, FALSE);
- size = AOP_SIZE (IC_LEFT (ic));
- /* push it on the stack */
- while (size--)
- {
- l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
- if (*l == '#')
- {
- MOVA (l);
- l = "acc";
- }
- emitcode ("push", "%s", l);
- }
- return;
- }
+ if (AOP_SIZE(result) > 0)
+ {
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+ }
- /* this is a paramter push: in this case we call
- the routine to find the call and save those
- registers that need to be saved */
- saveRegisters (ic);
+ if (ifx && IC_TRUE(ifx))
+ {
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ }
- /* if use external stack then call the external
- stack pushing routine */
- if (options.useXstack)
- {
- genXpush (ic);
- return;
- }
+ if (false_label && (!ifx || IC_TRUE(ifx)))
+ emitpLabel(false_label->key);
- /* then do the push */
- aopOp (IC_LEFT (ic), ic, FALSE);
+ if (ifx) ifx->generated = 1;
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
- // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
- size = AOP_SIZE (IC_LEFT (ic));
+/*-----------------------------------------------------------------*/
+/* ifxForOp - returns the icode containing the ifx for operand */
+/*-----------------------------------------------------------------*/
+static iCode *ifxForOp ( operand *op, iCode *ic )
+{
+ FENTRY;
+ /* if true symbol then needs to be assigned */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (IS_TRUE_SYMOP(op))
+ return NULL ;
+
+ /* if this has register type condition and
+ the next instruction is ifx with the same operand
+ and live to of the operand is upto the ifx only then */
+ if (ic->next &&
+ ic->next->op == IFX &&
+ IC_COND(ic->next)->key == op->key &&
+ OP_SYMBOL(op)->liveTo <= ic->next->seq )
+ return ic->next;
+
+ if (ic->next &&
+ ic->next->op == IFX &&
+ IC_COND(ic->next)->key == op->key) {
+ DEBUGpic14_emitcode ("; WARNING ","%d IGNORING liveTo range in %s",__LINE__,__FUNCTION__);
+ return ic->next;
+ }
+
+ DEBUGpic14_emitcode ("; NULL :(","%d",__LINE__);
+ if (ic->next &&
+ ic->next->op == IFX)
+ DEBUGpic14_emitcode ("; ic-next"," is an IFX");
+
+ if (ic->next &&
+ ic->next->op == IFX &&
+ IC_COND(ic->next)->key == op->key) {
+ DEBUGpic14_emitcode ("; "," key is okay");
+ DEBUGpic14_emitcode ("; "," key liveTo %d, next->seq = %d",
+ OP_SYMBOL(op)->liveTo,
+ ic->next->seq);
+ }
+
+
+ return NULL;
+}
+/*-----------------------------------------------------------------*/
+/* genAndOp - for && operation */
+/*-----------------------------------------------------------------*/
+static void genAndOp (iCode *ic)
+{
+ operand *left,*right, *result;
+ /* symbol *tlbl; */
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* note here that && operations that are in an
+ if statement are taken away by backPatchLabels
+ only those used in arthmetic operations remain */
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_ANDFW,popGet(AOP(right),0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+
+ /* if both are bit variables */
+ /* if (AOP_TYPE(left) == AOP_CRY && */
+ /* AOP_TYPE(right) == AOP_CRY ) { */
+ /* pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
+ /* pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
+ /* pic14_outBitC(result); */
+ /* } else { */
+ /* tlbl = newiTempLabel(NULL); */
+ /* pic14_toBoolean(left); */
+ /* pic14_emitcode("jz","%05d_DS_",tlbl->key+100); */
+ /* pic14_toBoolean(right); */
+ /* pic14_emitcode("","%05d_DS_:",tlbl->key+100); */
+ /* pic14_outBitAcc(result); */
+ /* } */
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
- while (size--)
- {
- l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
- if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG &&
- AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
- strcmp (l, "a"))
- {
- emitcode ("mov", "a,%s", l);
- emitcode ("push", "acc");
- }
- else
- emitcode ("push", "%s", l);
- }
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+/*-----------------------------------------------------------------*/
+/* genOrOp - for || operation */
+/*-----------------------------------------------------------------*/
+/*
+tsd pic port -
+modified this code, but it doesn't appear to ever get called
+*/
+
+static void genOrOp (iCode *ic)
+{
+ operand *left,*right, *result;
+ symbol *tlbl;
+ int i;
+
+ /* note here that || operations that are in an
+ if statement are taken away by backPatchLabels
+ only those used in arthmetic operations remain */
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ for (i=0; i < AOP_SIZE(result); i++)
+ {
+ emitpcode(POC_CLRF, popGet(AOP(result), i));
+ } // for i
+
+ tlbl = newiTempLabel(NULL);
+ pic14_toBoolean(left);
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(tlbl->key));
+ pic14_toBoolean(right);
+ emitpLabel(tlbl->key);
+ /* here Z is clear IFF `left || right' */
+ emitSKPZ;
+ emitpcode(POC_INCF, popGet(AOP(result), 0));
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
-/* genIpop - recover the registers: can happen only for spilling */
+/* isLiteralBit - test if lit == 2^n */
/*-----------------------------------------------------------------*/
-static void
-genIpop (iCode * ic)
+static int isLiteralBit(unsigned long lit)
{
- int size, offset;
-
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if the temp was not pushed then */
- if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
- return;
-
- aopOp (IC_LEFT (ic), ic, FALSE);
- size = AOP_SIZE (IC_LEFT (ic));
- offset = (size - 1);
- while (size--)
- emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
- FALSE, TRUE));
-
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+ unsigned long pw[32] = {1L,2L,4L,8L,16L,32L,64L,128L,
+ 0x100L,0x200L,0x400L,0x800L,
+ 0x1000L,0x2000L,0x4000L,0x8000L,
+ 0x10000L,0x20000L,0x40000L,0x80000L,
+ 0x100000L,0x200000L,0x400000L,0x800000L,
+ 0x1000000L,0x2000000L,0x4000000L,0x8000000L,
+ 0x10000000L,0x20000000L,0x40000000L,0x80000000L};
+ int idx;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ for(idx = 0; idx < 32; idx++)
+ if(lit == pw[idx])
+ return idx+1;
+ return 0;
}
/*-----------------------------------------------------------------*/
-/* unsaverbank - restores the resgister bank from stack */
+/* continueIfTrue - */
/*-----------------------------------------------------------------*/
-static void
-unsaverbank (int bank, iCode * ic, bool popPsw)
+static void continueIfTrue (iCode *ic)
{
- int i;
- asmop *aop;
- regs *r = NULL;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (popPsw)
- {
- if (options.useXstack)
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(IC_TRUE(ic))
{
- aop = newAsmop (0);
- r = getFreePtr (ic, &aop, FALSE);
-
-
- emitcode ("mov", "%s,_spx", r->name);
- emitcode ("movx", "a,@%s", r->name);
- emitcode ("mov", "psw,a");
- emitcode ("dec", "%s", r->name);
-
+ // Why +100?!?
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key+100));
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
}
- else
- emitcode ("pop", "psw");
- }
+ ic->generated = 1;
+}
- for (i = (pic14_nRegs - 1); i >= 0; i--)
- {
- if (options.useXstack)
+/*-----------------------------------------------------------------*/
+/* jmpIfTrue - */
+/*-----------------------------------------------------------------*/
+static void jumpIfTrue (iCode *ic)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(!IC_TRUE(ic))
{
- emitcode ("movx", "a,@%s", r->name);
- //emitcode("mov","(%s+%d),a",
- // regspic14[i].base,8*bank+regspic14[i].offset);
- emitcode ("dec", "%s", r->name);
-
+ // Why +100?!?
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key+100));
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
}
- else
- emitcode ("pop", ""); //"(%s+%d)",
- //regspic14[i].base,8*bank); //+regspic14[i].offset);
-
- }
-
- if (options.useXstack)
- {
-
- emitcode ("mov", "_spx,%s", r->name);
- freeAsmop (NULL, aop, ic, TRUE);
-
- }
+ ic->generated = 1;
}
/*-----------------------------------------------------------------*/
-/* saverbank - saves an entire register bank on the stack */
+/* jmpTrueOrFalse - */
/*-----------------------------------------------------------------*/
-static void
-saverbank (int bank, iCode * ic, bool pushPsw)
+static void jmpTrueOrFalse (iCode *ic, symbol *tlbl)
{
- int i;
- asmop *aop;
- regs *r = NULL;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (options.useXstack)
- {
-
- aop = newAsmop (0);
- r = getFreePtr (ic, &aop, FALSE);
- emitcode ("mov", "%s,_spx", r->name);
-
- }
-
- for (i = 0; i < pic14_nRegs; i++)
- {
- if (options.useXstack)
- {
- emitcode ("inc", "%s", r->name);
- //emitcode("mov","a,(%s+%d)",
- // regspic14[i].base,8*bank+regspic14[i].offset);
- emitcode ("movx", "@%s,a", r->name);
+ FENTRY;
+ // ugly but optimized by peephole
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(IC_TRUE(ic)){
+ symbol *nlbl = newiTempLabel(NULL);
+ pic14_emitcode("sjmp","%05d_DS_",nlbl->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
+ pic14_emitcode("","%05d_DS_:",nlbl->key+100);
}
- else
- emitcode ("push", ""); // "(%s+%d)",
- //regspic14[i].base,8*bank+regspic14[i].offset);
-
- }
+ else{
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ ic->generated = 1;
+}
- if (pushPsw)
- {
- if (options.useXstack)
- {
- emitcode ("mov", "a,psw");
- emitcode ("movx", "@%s,a", r->name);
- emitcode ("inc", "%s", r->name);
- emitcode ("mov", "_spx,%s", r->name);
- freeAsmop (NULL, aop, ic, TRUE);
+/*-----------------------------------------------------------------*/
+/* genAnd - code for and */
+/*-----------------------------------------------------------------*/
+static void genAnd (iCode *ic, iCode *ifx)
+{
+ operand *left, *right, *result;
+ int size, offset=0;
+ unsigned long lit = 0L;
+ int bytelit = 0;
+ resolvedIfx rIfx;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((right= IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ resolveIfx(&rIfx,ifx);
+
+ /* if left is a literal & right is not then exchange them */
+ if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
+ AOP_NEEDSACC(left)) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if result = right then exchange them */
+ if(pic14_sameRegs(AOP(result),AOP(right))){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if right is bit then exchange them */
+ if (AOP_TYPE(right) == AOP_CRY &&
+ AOP_TYPE(left) != AOP_CRY){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ // if(bit & yy)
+ // result = bit & yy;
+ if (AOP_TYPE(left) == AOP_CRY){
+ // c = bit & literal;
+ if(AOP_TYPE(right) == AOP_LIT){
+ if(lit & 1) {
+ if(size && pic14_sameRegs(AOP(result),AOP(left)))
+ // no change
+ goto release;
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ } else {
+ // bit(result) = 0;
+ if(size && (AOP_TYPE(result) == AOP_CRY)){
+ pic14_emitcode("clr","%s",AOP(result)->aopu.aop_dir);
+ goto release;
+ }
+ if((AOP_TYPE(result) == AOP_CRY) && ifx){
+ jumpIfTrue(ifx);
+ goto release;
+ }
+ pic14_emitcode("clr","c");
+ }
+ } else {
+ if (AOP_TYPE(right) == AOP_CRY){
+ // c = bit & bit;
+ pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+ pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
+ } else {
+ // c = bit & val;
+ MOVA(aopGet(AOP(right),0,FALSE,FALSE));
+ // c = lsb
+ pic14_emitcode("rrc","a");
+ pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
+ }
+ }
+ // bit = c
+ // val = c
+ if(size)
+ pic14_outBitC(result);
+ // if(bit & ...)
+ else if((AOP_TYPE(result) == AOP_CRY) && ifx)
+ genIfxJump(ifx, "c");
+ goto release ;
+ }
+
+ // if(val & 0xZZ) - size = 0, ifx != FALSE -
+ // bit = val & 0xZZ - size = 1, ifx = FALSE -
+ if((AOP_TYPE(right) == AOP_LIT) &&
+ (AOP_TYPE(result) == AOP_CRY) &&
+ (AOP_TYPE(left) != AOP_CRY)){
+ int posbit = isLiteralBit(lit);
+ /* left & 2^n */
+ if(posbit){
+ posbit--;
+ //MOVA(aopGet(AOP(left),posbit>>3,FALSE,FALSE));
+ // bit = left & 2^n
+ if(size)
+ pic14_emitcode("mov","c,acc.%d",posbit&0x07);
+ // if(left & 2^n)
+ else{
+ if(ifx){
+ int offset = 0;
+ while (posbit > 7) {
+ posbit -= 8;
+ offset++;
+ }
+ emitpcode(((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
+ newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit,0));
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+
+ ifx->generated = 1;
+ }
+ goto release;
+ }
+ } else {
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizel = AOP_SIZE(left);
+ if(size)
+ pic14_emitcode("setb","c");
+ while(sizel--){
+ if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
+ mov2w( AOP(left), offset);
+ // byte == 2^n ?
+ if((posbit = isLiteralBit(bytelit)) != 0) {
+ emitpcode(rIfx.condition ? POC_BTFSC : POC_BTFSS, // XXX: or the other way round?
+ newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit - 1, 0));
+ pic14_emitcode("jb","acc.%d,%05d_DS_",(posbit-1)&0x07,tlbl->key+100);
+ }
+ else{
+ emitpcode(POC_ANDLW, newpCodeOpLit(bytelit & 0x0ff));
+ if (rIfx.condition) emitSKPZ;
+ else emitSKPNZ;
+
+ if(bytelit != 0x0FFL)
+ {
+ pic14_emitcode("anl","a,%s",
+ aopGet(AOP(right),offset,FALSE,TRUE));
+ }
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ }
+
+ emitpcode(POC_GOTO, popGetLabel(rIfx.lbl->key));
+ ifx->generated = 1;
+
+ }
+ offset++;
+ }
+ // bit = left & literal
+ if(size){
+ pic14_emitcode("clr","c");
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ // if(left & literal)
+ else{
+ if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ goto release ;
+ }
+ }
+ pic14_outBitC(result);
+ goto release ;
+ }
+
+ /* if left is same as result */
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ int know_W = -1;
+ for(;size--; offset++,lit>>=8) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ switch(lit & 0xff) {
+ case 0x00:
+ /* and'ing with 0 has clears the result */
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
+ break;
+ case 0xff:
+ /* and'ing with 0xff is a nop when the result and left are the same */
+ break;
+
+ default:
+ {
+ int p = my_powof2( (~lit) & 0xff );
+ if(p>=0) {
+ /* only one bit is set in the literal, so use a bcf instruction */
+ emitpcode(POC_BCF,newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
+
+ } else {
+ if(know_W != (int)(lit&0xff))
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ know_W = lit &0xff;
+ emitpcode(POC_ANDWF,popGet(AOP(left),offset));
+ }
+ }
+ }
+ } else {
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_ANDFW,popGet(AOP(right),offset));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_ANDWF,popGet(AOP(left),offset));
+
+ }
+ }
+ }
+
+ } else {
+ // left & result in different registers
+ if(AOP_TYPE(result) == AOP_CRY){
+ // result = bit
+ // if(size), result in bit
+ // if(!size && ifx), conditional oper: if(left & right)
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizer = min(AOP_SIZE(left),AOP_SIZE(right));
+ if(size)
+ pic14_emitcode("setb","c");
+ while(sizer--){
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("anl","a,%s",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ offset++;
+ }
+ if(size){
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(result);
+ } else if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ } else {
+ for(;(size--);offset++) {
+ // normal case
+ // result = left & right
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ switch(t) {
+ case 0x00:
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
+ break;
+ case 0xff:
+ if(AOP_TYPE(left) != AOP_ACC) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ break;
+ default:
+ if(AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_ANDLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ }
+ continue;
+ }
+
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_ANDFW,popGet(AOP(right),offset));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ }
+ }
+ }
+
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
+/*-----------------------------------------------------------------*/
+/* genOr - code for or */
+/*-----------------------------------------------------------------*/
+static void genOr (iCode *ic, iCode *ifx)
+{
+ operand *left, *right, *result;
+ int size, offset=0;
+ unsigned long lit = 0L;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((right= IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ /* if left is a literal & right is not then exchange them */
+ if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
+ AOP_NEEDSACC(left)) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if result = right then exchange them */
+ if(pic14_sameRegs(AOP(result),AOP(right))){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if right is bit then exchange them */
+ if (AOP_TYPE(right) == AOP_CRY &&
+ AOP_TYPE(left) != AOP_CRY){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ // if(bit | yy)
+ // xx = bit | yy;
+ if (AOP_TYPE(left) == AOP_CRY){
+ if(AOP_TYPE(right) == AOP_LIT){
+ // c = bit & literal;
+ if(lit){
+ // lit != 0 => result = 1
+ if(AOP_TYPE(result) == AOP_CRY){
+ if(size)
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ //pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ // AOP(result)->aopu.aop_dir,
+ // AOP(result)->aopu.aop_dir);
+ else if(ifx)
+ continueIfTrue(ifx);
+ goto release;
+ }
+ } else {
+ // lit == 0 => result = left
+ if(size && pic14_sameRegs(AOP(result),AOP(left)))
+ goto release;
+ pic14_emitcode(";XXX mov","c,%s %s,%d",AOP(left)->aopu.aop_dir,__FILE__,__LINE__);
+ }
+ } else {
+ if (AOP_TYPE(right) == AOP_CRY){
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ // c = bit | bit;
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ } else {
+ if( AOP_TYPE(result) == AOP_ACC) {
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_MOVLW, popGetLit(1));
+
+ } else {
+
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(left)->aopu.aop_dir,
+ AOP(left)->aopu.aop_dir);
+ pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ }
+ }
+ } else {
+ // c = bit | val;
+ symbol *tlbl = newiTempLabel(NULL);
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+
+
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ if( AOP_TYPE(right) == AOP_ACC) {
+ emitpcode(POC_IORLW, popGetLit(0));
+ emitSKPNZ;
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ }
+
+
+
+ if(!((AOP_TYPE(result) == AOP_CRY) && ifx))
+ pic14_emitcode(";XXX setb","c");
+ pic14_emitcode(";XXX jb","%s,%05d_DS_",
+ AOP(left)->aopu.aop_dir,tlbl->key+100);
+ pic14_toBoolean(right);
+ pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
+ if((AOP_TYPE(result) == AOP_CRY) && ifx){
+ jmpTrueOrFalse(ifx, tlbl);
+ goto release;
+ } else {
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ }
+ }
+ // bit = c
+ // val = c
+ if(size)
+ pic14_outBitC(result);
+ // if(bit | ...)
+ else if((AOP_TYPE(result) == AOP_CRY) && ifx)
+ genIfxJump(ifx, "c");
+ goto release ;
+ }
+
+ // if(val | 0xZZ) - size = 0, ifx != FALSE -
+ // bit = val | 0xZZ - size = 1, ifx = FALSE -
+ if((AOP_TYPE(right) == AOP_LIT) &&
+ (AOP_TYPE(result) == AOP_CRY) &&
+ (AOP_TYPE(left) != AOP_CRY)){
+ if(lit){
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+ // result = 1
+ if(size)
+ pic14_emitcode(";XXX setb","%s",AOP(result)->aopu.aop_dir);
+ else
+ continueIfTrue(ifx);
+ goto release;
+ } else {
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+ // lit = 0, result = boolean(left)
+ if(size)
+ pic14_emitcode(";XXX setb","c");
+ pic14_toBoolean(right);
+ if(size){
+ symbol *tlbl = newiTempLabel(NULL);
+ pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ } else {
+ genIfxJump (ifx,"a");
+ goto release;
+ }
+ }
+ pic14_outBitC(result);
+ goto release ;
+ }
+
+ /* if left is same as result */
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ int know_W = -1;
+ for(;size--; offset++,lit>>=8) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ if((lit & 0xff) == 0)
+ /* or'ing with 0 has no effect */
+ continue;
+ else {
+ int p = my_powof2(lit & 0xff);
+ if(p>=0) {
+ /* only one bit is set in the literal, so use a bsf instruction */
+ emitpcode(POC_BSF,
+ newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
+ } else {
+ if(know_W != (int)(lit & 0xff))
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ know_W = lit & 0xff;
+ emitpcode(POC_IORWF, popGet(AOP(left),offset));
+ }
+
+ }
+ } else {
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORFW, popGet(AOP(right),offset));
+ pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_IORWF, popGet(AOP(left),offset));
+
+ pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("iorwf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
+
+ }
+ }
+ }
+ } else {
+ // left & result in different registers
+ if(AOP_TYPE(result) == AOP_CRY){
+ // result = bit
+ // if(size), result in bit
+ // if(!size && ifx), conditional oper: if(left | right)
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+
+
+ if(size)
+ pic14_emitcode(";XXX setb","c");
+ while(sizer--){
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode(";XXX orl","a,%s",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
+ offset++;
+ }
+ if(size){
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(result);
+ } else if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ } else for(;(size--);offset++){
+ // normal case
+ // result = left | right
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ switch(t) {
+ case 0x00:
+ if (AOP_TYPE(left) != AOP_ACC) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+ break;
+ default:
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_IORFW, popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+ continue;
+ }
+
+ // faster than result <- left, anl result,right
+ // and better if result is SFR
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORFW,popGet(AOP(right),offset));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_IORFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
}
- else
- emitcode ("push", "psw");
- emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
- }
- ic->bankSaved = 1;
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
+}
+/*-----------------------------------------------------------------*/
+/* genXor - code for xclusive or */
+/*-----------------------------------------------------------------*/
+static void genXor (iCode *ic, iCode *ifx)
+{
+ operand *left, *right, *result;
+ int size, offset=0;
+ unsigned long lit = 0L;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((right= IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ /* if left is a literal & right is not ||
+ if left needs acc & right does not */
+ if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
+ (AOP_NEEDSACC(left) && !AOP_NEEDSACC(right))) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if result = right then exchange them */
+ if(pic14_sameRegs(AOP(result),AOP(right))){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if right is bit then exchange them */
+ if (AOP_TYPE(right) == AOP_CRY &&
+ AOP_TYPE(left) != AOP_CRY){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ // if(bit ^ yy)
+ // xx = bit ^ yy;
+ if (AOP_TYPE(left) == AOP_CRY){
+ if(AOP_TYPE(right) == AOP_LIT){
+ // c = bit & literal;
+ if(lit>>1){
+ // lit>>1 != 0 => result = 1
+ if(AOP_TYPE(result) == AOP_CRY){
+ if(size)
+ {emitpcode(POC_BSF, popGet(AOP(result),offset));
+ pic14_emitcode("setb","%s",AOP(result)->aopu.aop_dir);}
+ else if(ifx)
+ continueIfTrue(ifx);
+ goto release;
+ }
+ pic14_emitcode("setb","c");
+ } else{
+ // lit == (0 or 1)
+ if(lit == 0){
+ // lit == 0, result = left
+ if(size && pic14_sameRegs(AOP(result),AOP(left)))
+ goto release;
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ } else{
+ // lit == 1, result = not(left)
+ if(size && pic14_sameRegs(AOP(result),AOP(left))){
+ emitpcode(POC_MOVLW, popGet(AOP(result),offset));
+ emitpcode(POC_XORWF, popGet(AOP(result),offset));
+ pic14_emitcode("cpl","%s",AOP(result)->aopu.aop_dir);
+ goto release;
+ } else {
+ assert ( !"incomplete genXor" );
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ }
+ }
+ }
+
+ } else {
+ // right != literal
+ symbol *tlbl = newiTempLabel(NULL);
+ if (AOP_TYPE(right) == AOP_CRY){
+ // c = bit ^ bit;
+ pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+ }
+ else{
+ int sizer = AOP_SIZE(right);
+ // c = bit ^ val
+ // if val>>1 != 0, result = 1
+ pic14_emitcode("setb","c");
+ while(sizer){
+ MOVA(aopGet(AOP(right),sizer-1,FALSE,FALSE));
+ if(sizer == 1)
+ // test the msb of the lsb
+ pic14_emitcode("anl","a,#0xfe");
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ sizer--;
+ }
+ // val = (0,1)
+ pic14_emitcode("rrc","a");
+ }
+ pic14_emitcode("jnb","%s,%05d_DS_",AOP(left)->aopu.aop_dir,(tlbl->key+100));
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",(tlbl->key+100));
+ }
+ // bit = c
+ // val = c
+ if(size)
+ pic14_outBitC(result);
+ // if(bit | ...)
+ else if((AOP_TYPE(result) == AOP_CRY) && ifx)
+ genIfxJump(ifx, "c");
+ goto release ;
+ }
+
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ /* if left is same as result */
+ for(;size--; offset++) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ if(t == 0x00L)
+ continue;
+ else
+ if (IS_AOP_PREG(left)) {
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
+ aopPut(AOP(result),"a",offset);
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_XORWF,popGet(AOP(left),offset));
+ pic14_emitcode("xrl","%s,%s",
+ aopGet(AOP(left),offset,FALSE,TRUE),
+ aopGet(AOP(right),offset,FALSE,FALSE));
+ }
+ } else {
+ if (AOP_TYPE(left) == AOP_ACC)
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE));
+ else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_XORWF,popGet(AOP(left),offset));
+ /*
+ if (IS_AOP_PREG(left)) {
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
+ aopPut(AOP(result),"a",offset);
+ } else
+ pic14_emitcode("xrl","%s,a",
+ aopGet(AOP(left),offset,FALSE,TRUE));
+ */
+ }
+ }
+ }
+ } else {
+ // left & result in different registers
+ if(AOP_TYPE(result) == AOP_CRY){
+ // result = bit
+ // if(size), result in bit
+ // if(!size && ifx), conditional oper: if(left ^ right)
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
+ if(size)
+ pic14_emitcode("setb","c");
+ while(sizer--){
+ if((AOP_TYPE(right) == AOP_LIT) &&
+ (((lit >> (offset*8)) & 0x0FFL) == 0x00L)){
+ MOVA(aopGet(AOP(left),offset,FALSE,FALSE));
+ } else {
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("xrl","a,%s",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ }
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ offset++;
+ }
+ if(size){
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(result);
+ } else if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ } else for(;(size--);offset++){
+ // normal case
+ // result = left & right
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ switch(t) {
+ case 0x00:
+ if (AOP_TYPE(left) != AOP_ACC) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ pic14_emitcode("movf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+ break;
+ case 0xff:
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_COMFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ break;
+ default:
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_XORFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ pic14_emitcode("movlw","0x%x",t);
+ pic14_emitcode("xorwf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+
+ }
+ continue;
+ }
+
+ // faster than result <- left, anl result,right
+ // and better if result is SFR
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_XORFW,popGet(AOP(left),offset));
+ }
+ if ( AOP_TYPE(result) != AOP_ACC){
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ }
+ }
+ }
+
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
-/* genCall - generates a call statement */
+/* genInline - write the inline code out */
/*-----------------------------------------------------------------*/
-static void
-genCall (iCode * ic)
+static void genInline (iCode *ic)
{
- sym_link *detype;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
+ char *buffer, *bp, *bp1;
- /* if caller saves & we have not saved then */
- if (!ic->regsSaved)
- saveRegisters (ic);
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if we are calling a function that is not using
- the same register bank then we need to save the
- destination registers on the stack */
- detype = getSpec (operandType (IC_LEFT (ic)));
- if (detype &&
- (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
- IS_ISR (currFunc->etype) &&
- !ic->bankSaved)
-
- saverbank (SPEC_BANK (detype), ic, TRUE);
+ _G.inLine += (!options.asmpeep);
- /* if send set is not empty the assign */
- if (_G.sendSet)
- {
- iCode *sic;
+ buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
+ strcpy(buffer,IC_INLINE(ic));
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet))
- {
- int size, offset = 0;
+ /* emit each line as a code */
+ while (*bp) {
+ if (*bp == '\n') {
+ *bp++ = '\0';
+
+ if(*bp1)
+ addpCode2pBlock(pb, newpCodeAsmDir(bp1, NULL)); // inline directly, no process
+ bp1 = bp;
+ } else {
+ if (*bp == ':') {
+ bp++;
+ *bp = '\0';
+ bp++;
+
+ /* print label, use this special format with NULL directive
+ * to denote that the argument should not be indented with tab */
+ addpCode2pBlock(pb, newpCodeAsmDir(NULL, bp1)); // inline directly, no process
+
+ bp1 = bp;
+ } else
+ bp++;
+ }
+ }
+ if ((bp1 != bp) && *bp1)
+ addpCode2pBlock(pb, newpCodeAsmDir(bp1, NULL)); // inline directly, no process
- aopOp (IC_LEFT (sic), sic, FALSE);
- size = AOP_SIZE (IC_LEFT (sic));
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (sic)), offset,
- FALSE, FALSE);
- DEBUGemitcode (";", "%d - left type %d", __LINE__, AOP (IC_LEFT (sic))->type);
+ Safe_free(buffer);
- if (strcmp (l, fReturn[offset]))
- {
+ _G.inLine -= (!options.asmpeep);
+}
- if (((AOP (IC_LEFT (sic))->type) == AOP_IMMD) ||
- ((AOP (IC_LEFT (sic))->type) == AOP_LIT))
- emitcode ("movlw", "%s", l);
- else
- emitcode ("movf", "%s,w", l);
- // The last one is past in W
- if (size)
- emitcode ("movwf", "%s", fReturn[offset]);
- }
- offset++;
- }
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+/*-----------------------------------------------------------------*/
+/* genRRC - rotate right with carry */
+/*-----------------------------------------------------------------*/
+static void genRRC (iCode *ic)
+{
+ operand *left , *result ;
+ int size, offset = 0, same;
+
+ FENTRY;
+ /* rotate right with carry */
+ left = IC_LEFT(ic);
+ result=IC_RESULT(ic);
+ aopOp (left,ic,FALSE);
+ aopOp (result,ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ same = pic14_sameRegs(AOP(result),AOP(left));
+
+ size = AOP_SIZE(result);
+
+ /* get the lsb and put it into the carry */
+ emitpcode(POC_RRFW, popGet(AOP(left),size-1));
+
+ offset = 0 ;
+
+ while(size--) {
+
+ if(same) {
+ emitpcode(POC_RRF, popGet(AOP(left),offset));
+ } else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+
+ offset++;
}
- _G.sendSet = NULL;
- }
- /* make the call */
- emitcode ("call", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
- OP_SYMBOL (IC_LEFT (ic))->rname :
- OP_SYMBOL (IC_LEFT (ic))->name));
-
- /* if we need assign a result value */
- if ((IS_ITEMP (IC_RESULT (ic)) &&
- (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
- OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
- IS_TRUE_SYMOP (IC_RESULT (ic)))
- {
-
- _G.accInUse++;
- aopOp (IC_RESULT (ic), ic, FALSE);
- _G.accInUse--;
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
- assignResultValue (IC_RESULT (ic));
+/*-----------------------------------------------------------------*/
+/* genRLC - generate code for rotate left with carry */
+/*-----------------------------------------------------------------*/
+static void genRLC (iCode *ic)
+{
+ operand *left , *result ;
+ int size, offset = 0;
+ int same;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* rotate right with carry */
+ left = IC_LEFT(ic);
+ result=IC_RESULT(ic);
+ aopOp (left,ic,FALSE);
+ aopOp (result,ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ same = pic14_sameRegs(AOP(result),AOP(left));
+
+ /* move it to the result */
+ size = AOP_SIZE(result);
+
+ /* get the msb and put it into the carry */
+ emitpcode(POC_RLFW, popGet(AOP(left),size-1));
+
+ offset = 0 ;
+
+ while(size--) {
+
+ if(same) {
+ emitpcode(POC_RLF, popGet(AOP(left),offset));
+ } else {
+ emitpcode(POC_RLFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+
+ offset++;
+ }
+
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
- }
+/*-----------------------------------------------------------------*/
+/* genGetHbit - generates code get highest order bit */
+/*-----------------------------------------------------------------*/
+static void genGetHbit (iCode *ic)
+{
+ operand *left, *result;
+ left = IC_LEFT(ic);
+ result=IC_RESULT(ic);
+ aopOp (left,ic,FALSE);
+ aopOp (result,ic,FALSE);
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* get the highest order byte into a */
+ MOVA(aopGet(AOP(left),AOP_SIZE(left) - 1,FALSE,FALSE));
+ if(AOP_TYPE(result) == AOP_CRY){
+ pic14_emitcode("rlc","a");
+ pic14_outBitC(result);
+ }
+ else{
+ pic14_emitcode("rl","a");
+ pic14_emitcode("anl","a,#0x01");
+ pic14_outAcc(result);
+ }
+
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* AccLsh - shift left accumulator by known count */
+/* MARK: pic14 always rotates through CARRY! */
+/*-----------------------------------------------------------------*/
+static void AccLsh (pCodeOp *pcop,int shCount)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shCount &= 0x0007; // shCount : 0..7
+ switch(shCount){
+ case 0 :
+ return;
+ break;
+ case 1 :
+ emitCLRC;
+ emitpcode(POC_RLF,pcop);
+ return;
+ break;
+ case 2 :
+ emitpcode(POC_RLF,pcop);
+ emitpcode(POC_RLF,pcop);
+ break;
+ case 3 :
+ emitpcode(POC_RLF,pcop);
+ emitpcode(POC_RLF,pcop);
+ emitpcode(POC_RLF,pcop);
+ break;
+ case 4 :
+ emitpcode(POC_SWAPF,pcop);
+ break;
+ case 5 :
+ emitpcode(POC_SWAPF,pcop);
+ emitpcode(POC_RLF,pcop);
+ break;
+ case 6 :
+ emitpcode(POC_SWAPF,pcop);
+ emitpcode(POC_RLF,pcop);
+ emitpcode(POC_RLF,pcop);
+ break;
+ case 7 :
+ emitpcode(POC_RRFW,pcop);
+ emitpcode(POC_RRF,pcop);
+ break;
+ }
+ /* clear invalid bits */
+ emitpcode(POC_MOVLW, popGetLit ((unsigned char)(~((1UL << shCount) - 1))));
+ emitpcode(POC_ANDWF, pcop);
+}
+
+/*-----------------------------------------------------------------*/
+/* AccRsh - shift right accumulator by known count */
+/* MARK: pic14 always rotates through CARRY! */
+/* maskmode - 0: leave invalid bits undefined (caller should mask) */
+/* 1: mask out invalid bits (zero-extend) */
+/* 2: sign-extend result (pretty slow) */
+/*-----------------------------------------------------------------*/
+static void AccRsh (pCodeOp *pcop,int shCount, int mask_mode)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shCount &= 0x0007; // shCount : 0..7
+ switch(shCount){
+ case 0 :
+ return;
+ break;
+ case 1 :
+ /* load sign if needed */
+ if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
+ else if (mask_mode == 1) emitCLRC;
+ emitpcode(POC_RRF,pcop);
+ return;
+ break;
+ case 2 :
+ /* load sign if needed */
+ if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_RRF,pcop);
+ /* load sign if needed */
+ if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_RRF,pcop);
+ if (mask_mode == 2) return;
+ break;
+ case 3 :
+ /* load sign if needed */
+ if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_RRF,pcop);
+ /* load sign if needed */
+ if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_RRF,pcop);
+ /* load sign if needed */
+ if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_RRF,pcop);
+ if (mask_mode == 2) return;
+ break;
+ case 4 :
+ emitpcode(POC_SWAPF,pcop);
+ break;
+ case 5 :
+ emitpcode(POC_SWAPF,pcop);
+ emitpcode(POC_RRF,pcop);
+ break;
+ case 6 :
+ emitpcode(POC_SWAPF,pcop);
+ emitpcode(POC_RRF,pcop);
+ emitpcode(POC_RRF,pcop);
+ break;
+ case 7 :
+ if (mask_mode == 2)
+ {
+ /* load sign */
+ emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_CLRF,pcop);
+ emitSKPNC;
+ emitpcode(POC_COMF,pcop);
+ return;
+ } else {
+ emitpcode(POC_RLFW,pcop);
+ emitpcode(POC_RLF,pcop);
+ }
+ break;
+ }
- /* adjust the stack for parameters if
- required */
- if (IC_LEFT (ic)->parmBytes)
- {
- int i;
- if (IC_LEFT (ic)->parmBytes > 3)
+ if (mask_mode == 0)
{
- emitcode ("mov", "a,%s", spname);
- emitcode ("add", "a,#0x%02x", (-IC_LEFT (ic)->parmBytes) & 0xff);
- emitcode ("mov", "%s,a", spname);
+ /* leave invalid bits undefined */
+ return;
}
- else
- for (i = 0; i < IC_LEFT (ic)->parmBytes; i++)
- emitcode ("dec", "%s", spname);
-
- }
-
- /* if register bank was saved then pop them */
- if (ic->bankSaved)
- unsaverbank (SPEC_BANK (detype), ic, TRUE);
-
- /* if we hade saved some registers then unsave them */
- if (ic->regsSaved && !(OP_SYMBOL (IC_LEFT (ic))->calleeSave))
- unsaveRegisters (ic);
-
+
+ /* clear invalid bits -- zero-extend */
+ emitpcode(POC_MOVLW, popGetLit (0x00ff >> shCount));
+ emitpcode(POC_ANDWF, pcop);
+ if (mask_mode == 2) {
+ /* sign-extend */
+ emitpcode(POC_MOVLW, popGetLit (0x00ff << (8 - shCount)));
+ emitpcode(POC_BTFSC, newpCodeOpBit (get_op(pcop,NULL,0), 7 - shCount ,0));
+ emitpcode(POC_IORWF, pcop);
+ }
}
+#if 0
/*-----------------------------------------------------------------*/
-/* genPcall - generates a call by pointer statement */
+/* AccSRsh - signed right shift accumulator by known count */
/*-----------------------------------------------------------------*/
-static void
-genPcall (iCode * ic)
-{
- sym_link *detype;
- symbol *rlbl = newiTempLabel (NULL);
-
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if caller saves & we have not saved then */
- if (!ic->regsSaved)
- saveRegisters (ic);
-
- /* if we are calling a function that is not using
- the same register bank then we need to save the
- destination registers on the stack */
- detype = getSpec (operandType (IC_LEFT (ic)));
- if (detype &&
- IS_ISR (currFunc->etype) &&
- (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)))
- saverbank (SPEC_BANK (detype), ic, TRUE);
-
-
- /* push the return address on to the stack */
- emitcode ("mov", "a,#%05d_DS_", (rlbl->key + 100));
- emitcode ("push", "acc");
- emitcode ("mov", "a,#(%05d_DS_ >> 8)", (rlbl->key + 100));
- emitcode ("push", "acc");
-
- if (options.model == MODEL_FLAT24)
- {
- emitcode ("mov", "a,#(%05d_DS_ >> 16)", (rlbl->key + 100));
- emitcode ("push", "acc");
- }
-
- /* now push the calling address */
- aopOp (IC_LEFT (ic), ic, FALSE);
+static void AccSRsh (int shCount)
+{
+ symbol *tlbl ;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(shCount != 0){
+ if(shCount == 1){
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ } else if(shCount == 2){
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ } else {
+ tlbl = newiTempLabel(NULL);
+ /* rotate right accumulator */
+ AccRol(8 - shCount);
+ /* and kill the higher order bits */
+ pic14_emitcode("anl","a,#0x%02x", SRMask[shCount]);
+ pic14_emitcode("jnb","acc.%d,%05d_DS_",7-shCount,tlbl->key+100);
+ pic14_emitcode("orl","a,#0x%02x",
+ (unsigned char)~SRMask[shCount]);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ }
+}
- pushSide (IC_LEFT (ic), FPTRSIZE);
+/*-----------------------------------------------------------------*/
+/* shiftR1Left2Result - shift right one byte from left to result */
+/*-----------------------------------------------------------------*/
+static void shiftR1Left2ResultSigned (operand *left, int offl,
+ operand *result, int offr,
+ int shCount)
+{
+ int same;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+ switch(shCount) {
+ case 1:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ if(same)
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+
+ break;
+ case 2:
+
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ if(same)
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+ break;
+
+ case 3:
+ if(same)
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0x1f));
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+ emitpcode(POC_IORLW, popGetLit(0xe0));
+
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 4:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_IORLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+ case 5:
+ if(same) {
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ emitpcode(POC_RRFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0x07));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+ emitpcode(POC_IORLW, popGetLit(0xf8));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 6:
+ if(same) {
+ emitpcode(POC_MOVLW, popGetLit(0x00));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xfe));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+ emitpcode(POC_IORLW, popGetLit(0x01));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),offr));
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+ emitpcode(POC_BCF, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),0,0));
+ }
+ break;
+
+ case 7:
+ if(same) {
+ emitpcode(POC_MOVLW, popGetLit(0x00));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),offr));
+ }
+
+ default:
+ break;
+ }
+}
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+/*-----------------------------------------------------------------*/
+/* shiftR1Left2Result - shift right one byte from left to result */
+/*-----------------------------------------------------------------*/
+static void shiftR1Left2Result (operand *left, int offl,
+ operand *result, int offr,
+ int shCount, int sign)
+{
+ int same;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+ /* Copy the msb into the carry if signed. */
+ if(sign) {
+ shiftR1Left2ResultSigned(left,offl,result,offr,shCount);
+ return;
+ }
+
+
+
+ switch(shCount) {
+ case 1:
+ emitCLRC;
+ if(same)
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ break;
+ case 2:
+ emitCLRC;
+ if(same) {
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ emitCLRC;
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+ break;
+ case 3:
+ if(same)
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0x1f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 4:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 5:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitCLRC;
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+ break;
+ case 6:
+
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x80));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ break;
+
+ case 7:
+
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+
+ break;
+
+ default:
+ break;
+ }
+}
- /* if send set is not empty the assign */
- if (_G.sendSet)
- {
- iCode *sic;
+/*-----------------------------------------------------------------*/
+/* shiftL1Left2Result - shift left one byte from left to result */
+/*-----------------------------------------------------------------*/
+static void shiftL1Left2Result (operand *left, int offl,
+ operand *result, int offr, int shCount)
+{
+ int same;
+
+ // char *l;
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ same = ((left == result) || (AOP(left) == AOP(result))) && (offl==offr);
+ DEBUGpic14_emitcode ("; ***","same = %d",same);
+ // l = aopGet(AOP(left),offl,FALSE,FALSE);
+ // MOVA(l);
+ /* shift left accumulator */
+ //AccLsh(shCount); // don't comment out just yet...
+ // aopPut(AOP(result),"a",offr);
+
+ switch(shCount) {
+ case 1:
+ /* Shift left 1 bit position */
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ if(same) {
+ emitpcode(POC_ADDWF, popGet(AOP(left),offl));
+ } else {
+ emitpcode(POC_ADDFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ break;
+ case 2:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW,popGetLit(0x7e));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ break;
+ case 3:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW,popGetLit(0x3e));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ break;
+ case 4:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ break;
+ case 5:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ break;
+ case 6:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x30));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ break;
+ case 7:
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ break;
+
+ default:
+ DEBUGpic14_emitcode ("; ***","%s %d, shift count is %d",__FUNCTION__,__LINE__,shCount);
+ }
+
+}
+#endif
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet))
- {
- int size, offset = 0;
- aopOp (IC_LEFT (sic), sic, FALSE);
- size = AOP_SIZE (IC_LEFT (sic));
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (sic)), offset,
- FALSE, FALSE);
- if (strcmp (l, fReturn[offset]))
- emitcode ("mov", "%s,%s",
- fReturn[offset],
- l);
- offset++;
- }
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+/*-----------------------------------------------------------------*/
+/* movLeft2Result - move byte from left to result */
+/*-----------------------------------------------------------------*/
+static void movLeft2Result (operand *left, int offl,
+ operand *result, int offr)
+{
+ char *l;
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(!pic14_sameRegs(AOP(left),AOP(result)) || (offl != offr)){
+ l = aopGet(AOP(left),offl,FALSE,FALSE);
+
+ if (*l == '@' && (IS_AOP_PREG(result))) {
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offr);
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
}
- _G.sendSet = NULL;
- }
+}
- emitcode ("ret", "");
- emitcode ("", "%05d_DS_:", (rlbl->key + 100));
+/*-----------------------------------------------------------------*/
+/* shiftLeft_Left2ResultLit - shift left by known count */
+/*-----------------------------------------------------------------*/
+
+static void shiftLeft_Left2ResultLit (operand *left, operand *result, int shCount)
+{
+ int size, same, offr, i;
+
+ size = AOP_SIZE(left);
+ if (AOP_SIZE(result) < size) size = AOP_SIZE(result);
+
+ same = pic14_sameRegs (AOP(left), AOP(result));
+
+ offr = shCount / 8;
+ shCount = shCount & 0x07;
+
+ size -= offr;
+
+ switch (shCount)
+ {
+ case 0: /* takes 0 or 2N cycles (for offr==0) */
+ if (!same || offr) {
+ for (i=size-1; i >= 0; i--)
+ movLeft2Result (left, i, result, offr + i);
+ } // if
+ break;
+
+ case 1: /* takes 1N+1 or 2N+1 cycles (or offr==0) */
+ if (same && offr) {
+ shiftLeft_Left2ResultLit (left, result, 8 * offr);
+ shiftLeft_Left2ResultLit (result, result, shCount);
+ return; /* prevent clearing result again */
+ } else {
+ emitCLRC;
+ for (i=0; i < size; i++) {
+ if (same && !offr) {
+ emitpcode (POC_RLF, popGet (AOP(left), i));
+ } else {
+ emitpcode (POC_RLFW, popGet (AOP(left), i));
+ emitpcode (POC_MOVWF, popGet (AOP(result), i + offr));
+ } // if
+ } // for
+ } // if (offr)
+ break;
+
+ case 4: /* takes 3+5(N-1) = 5N-2 cycles (for offr==0) */
+ /* works in-place/with offr as well */
+ emitpcode (POC_SWAPFW, popGet (AOP(left), size-1));
+ emitpcode (POC_ANDLW, popGetLit (0xF0));
+ emitpcode (POC_MOVWF, popGet(AOP(result), size-1+offr));
+
+ for (i = size - 2; i >= 0; i--)
+ {
+ emitpcode (POC_SWAPFW, popGet (AOP(left), i));
+ emitpcode (POC_MOVWF, popGet (AOP(result), i + offr));
+ emitpcode (POC_ANDLW, popGetLit (0x0F));
+ emitpcode (POC_IORWF, popGet (AOP(result), i + offr + 1));
+ emitpcode (POC_XORWF, popGet (AOP(result), i + offr));
+ } // for i
+ break;
+
+ case 7: /* takes 2(N-1)+3 = 2N+1 cycles */
+ /* works in-place/with offr as well */
+ emitpcode (POC_RRFW, popGet (AOP(left), size-1));
+ for (i = size-2; i >= 0; i--) {
+ emitpcode (POC_RRFW, popGet (AOP(left), i));
+ emitpcode (POC_MOVWF, popGet (AOP(result), offr + i + 1));
+ } // for i
+ emitpcode (POC_CLRF, popGet (AOP(result), offr));
+ emitpcode (POC_RRF, popGet (AOP(result), offr));
+ break;
+
+ default:
+ shiftLeft_Left2ResultLit (left, result, offr * 8 + shCount-1);
+ shiftLeft_Left2ResultLit (result, result, 1);
+ return; /* prevent clearing result again */
+ break;
+ } // switch
+ while (0 < offr--)
+ {
+ emitpcode (POC_CLRF, popGet (AOP(result), offr));
+ } // while
+}
- /* if we need assign a result value */
- if ((IS_ITEMP (IC_RESULT (ic)) &&
- (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
- OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
- IS_TRUE_SYMOP (IC_RESULT (ic)))
- {
+/*-----------------------------------------------------------------*/
+/* shiftRight_Left2ResultLit - shift right by known count */
+/*-----------------------------------------------------------------*/
- _G.accInUse++;
- aopOp (IC_RESULT (ic), ic, FALSE);
- _G.accInUse--;
+static void shiftRight_Left2ResultLit (operand *left, operand *result, int shCount, int sign)
+{
+ int size, same, offr, i;
- assignResultValue (IC_RESULT (ic));
+ size = AOP_SIZE(left);
+ if (AOP_SIZE(result) < size) size = AOP_SIZE(result);
+
+ same = pic14_sameRegs (AOP(left), AOP(result));
+
+ offr = shCount / 8;
+ shCount = shCount & 0x07;
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
- }
+ size -= offr;
- /* adjust the stack for parameters if
- required */
- if (IC_LEFT (ic)->parmBytes)
- {
- int i;
- if (IC_LEFT (ic)->parmBytes > 3)
+ if (size)
{
- emitcode ("mov", "a,%s", spname);
- emitcode ("add", "a,#0x%02x", (-IC_LEFT (ic)->parmBytes) & 0xff);
- emitcode ("mov", "%s,a", spname);
- }
- else
- for (i = 0; i < IC_LEFT (ic)->parmBytes; i++)
- emitcode ("dec", "%s", spname);
-
- }
-
- /* if register bank was saved then unsave them */
- if (detype &&
- (SPEC_BANK (currFunc->etype) !=
- SPEC_BANK (detype)))
- unsaverbank (SPEC_BANK (detype), ic, TRUE);
-
- /* if we hade saved some registers then
- unsave them */
- if (ic->regsSaved)
- unsaveRegisters (ic);
+ switch (shCount)
+ {
+ case 0: /* takes 0 or 2N cycles (for offr==0) */
+ if (!same || offr) {
+ for (i=0; i < size; i++)
+ movLeft2Result (left, i + offr, result, i);
+ } // if
+ break;
+
+ case 1: /* takes 1N+1(3) or 2N+1(3) cycles (or offr==0) */
+ emitpComment ("%s:%d: shCount=%d, size=%d, sign=%d, same=%d, offr=%d", __FUNCTION__, __LINE__, shCount, size, sign, same, offr);
+ if (same && offr) {
+ shiftRight_Left2ResultLit (left, result, 8 * offr, sign);
+ shiftRight_Left2ResultLit (result, result, shCount, sign);
+ return; /* prevent sign-extending result again */
+ } else {
+ emitCLRC;
+ if (sign) {
+ emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP(left), AOP_SIZE(left)-1, FALSE, FALSE), 7, 0));
+ emitSETC;
+ }
+ for (i = size-1; i >= 0; i--) {
+ if (same && !offr) {
+ emitpcode (POC_RRF, popGet (AOP(left), i));
+ } else {
+ emitpcode (POC_RRFW, popGet (AOP(left), i + offr));
+ emitpcode (POC_MOVWF, popGet (AOP(result), i));
+ }
+ } // for i
+ } // if (offr)
+ break;
+
+ case 4: /* takes 3(6)+5(N-1) = 5N-2(+1) cycles (for offr==0) */
+ /* works in-place/with offr as well */
+ emitpcode (POC_SWAPFW, popGet (AOP(left), offr));
+ emitpcode (POC_ANDLW, popGetLit (0x0F));
+ emitpcode (POC_MOVWF, popGet(AOP(result), 0));
+
+ for (i = 1; i < size; i++)
+ {
+ emitpcode (POC_SWAPFW, popGet (AOP(left), i + offr));
+ emitpcode (POC_MOVWF, popGet (AOP(result), i));
+ emitpcode (POC_ANDLW, popGetLit (0xF0));
+ emitpcode (POC_IORWF, popGet (AOP(result), i - 1));
+ emitpcode (POC_XORWF, popGet (AOP(result), i));
+ } // for i
+
+ if (sign)
+ {
+ emitpcode (POC_MOVLW, popGetLit (0xF0));
+ emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP(result), size-1, FALSE, FALSE), 3, 0));
+ emitpcode (POC_IORWF, popGet (AOP(result), size-1));
+ } // if
+ break;
+
+ case 7: /* takes 2(N-1)+3(4) = 2N+1(2) cycles */
+ /* works in-place/with offr as well */
+ emitpcode (POC_RLFW, popGet (AOP(left), offr));
+ for (i = 0; i < size-1; i++) {
+ emitpcode (POC_RLFW, popGet (AOP(left), offr + i + 1));
+ emitpcode (POC_MOVWF, popGet (AOP(result), i));
+ } // for i
+ emitpcode (POC_CLRF, popGet (AOP(result), size-1));
+ if (!sign) {
+ emitpcode (POC_RLF, popGet (AOP(result), size-1));
+ } else {
+ emitSKPNC;
+ emitpcode (POC_DECF, popGet (AOP(result), size-1));
+ }
+ break;
+
+ default:
+ shiftRight_Left2ResultLit (left, result, offr * 8 + shCount-1, sign);
+ shiftRight_Left2ResultLit (result, result, 1, sign);
+ return; /* prevent sign extending result again */
+ break;
+ } // switch
+ } // if
+ addSign (result, size, sign);
}
+#if 0
/*-----------------------------------------------------------------*/
-/* resultRemat - result is rematerializable */
+/* shiftL2Left2Result - shift left two bytes from left to result */
/*-----------------------------------------------------------------*/
-static int
-resultRemat (iCode * ic)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (SKIP_IC (ic) || ic->op == IFX)
- return 0;
-
- if (IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic)))
- {
- symbol *sym = OP_SYMBOL (IC_RESULT (ic));
- if (sym->remat && !POINTER_SET (ic))
- return 1;
- }
-
- return 0;
+static void shiftL2Left2Result (operand *left, int offl,
+ operand *result, int offr, int shCount)
+{
+ FENTRY;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(pic14_sameRegs(AOP(result), AOP(left))) {
+ switch(shCount) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 3:
+
+ emitpcode(POC_MOVFW,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+
+ while(--shCount) {
+ emitCLRC;
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+
+ break;
+ case 4:
+ case 5:
+ emitpcode(POC_MOVLW, popGetLit(0x0f));
+ emitpcode(POC_ANDWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ emitpcode(POC_ANDFW, popGet(AOP(result),offr));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+ if(shCount >=5) {
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+ break;
+ case 6:
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW,popGetLit(0xc0));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ break;
+ case 7:
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ }
+
+ } else {
+ switch(shCount) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 3:
+ /* note, use a mov/add for the shift since the mov has a
+ chance of getting optimized out */
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+
+ while(--shCount) {
+ emitCLRC;
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+ break;
+
+ case 4:
+ case 5:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_ANDLW, popGetLit(0xF0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0xF0));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+
+
+ if(shCount == 5) {
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+ break;
+ case 6:
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(result),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW,popGetLit(0xc0));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ break;
+ case 7:
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ }
+ }
+
}
-#if defined(__BORLANDC__) || defined(_MSC_VER)
-#define STRCASECMP stricmp
-#else
-#define STRCASECMP strcasecmp
-#endif
+/*-----------------------------------------------------------------*/
+/* shiftR2Left2Result - shift right two bytes from left to result */
+/*-----------------------------------------------------------------*/
+static void shiftR2Left2Result (operand *left, int offl,
+ operand *result, int offr,
+ int shCount, int sign)
+{
+ int same=0;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ same = pic14_sameRegs(AOP(result), AOP(left));
+
+ if(same && ((offl + MSB16) == offr)){
+ same=1;
+ /* don't crash result[offr] */
+ MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
+ pic14_emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
+ }
+ /* else {
+ movLeft2Result(left,offl, result, offr);
+ MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
+ }
+ */
+ /* a:x >> shCount (x = lsb(result))*/
+ /*
+ if(sign)
+ AccAXRshS( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
+ else {
+ AccAXRsh( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
+ */
+ switch(shCount) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 3:
+ if(sign)
+ emitpcode(POC_RLFW,popGet(AOP(left),offl+MSB16));
+ else
+ emitCLRC;
+
+ if(same) {
+ emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF,popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ }
+
+ while(--shCount) {
+ if(sign)
+ emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
+ else
+ emitCLRC;
+ emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF,popGet(AOP(result),offr));
+ }
+ break;
+ case 4:
+ case 5:
+ if(same) {
+
+ emitpcode(POC_MOVLW, popGetLit(0xf0));
+ emitpcode(POC_ANDWF, popGet(AOP(result),offr));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ }
+
+ if(shCount >=5) {
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ }
+
+ if(sign) {
+ emitpcode(POC_MOVLW, popGetLit(0xf0 + (shCount-4)*8 ));
+ emitpcode(POC_BTFSC,
+ newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+ }
+
+ break;
+
+ case 6:
+ if(same) {
+
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW,popGetLit(0x03));
+ if(sign) {
+ emitpcode(POC_BTFSC,
+ newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0));
+ emitpcode(POC_IORLW,popGetLit(0xfc));
+ }
+ emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW,popGetLit(0x03));
+ if(sign) {
+ emitpcode(POC_BTFSC,
+ newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
+ emitpcode(POC_IORLW,popGetLit(0xfc));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ //emitpcode(POC_RLF, popGet(AOP(result),offr));
+
+
+ }
+
+ break;
+ case 7:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16));
+ if(sign) {
+ emitSKPNC;
+ emitpcode(POC_DECF, popGet(AOP(result),offr+MSB16));
+ } else
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+}
/*-----------------------------------------------------------------*/
-/* inExcludeList - return 1 if the string is in exclude Reg list */
+/* shiftLLeftOrResult - shift left one byte from left, or to result*/
/*-----------------------------------------------------------------*/
-static bool
-inExcludeList (char *s)
+static void shiftLLeftOrResult (operand *left, int offl,
+ operand *result, int offr, int shCount)
{
- int i = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (options.excludeRegs[i] &&
- STRCASECMP (options.excludeRegs[i], "none") == 0)
- return FALSE;
-
- for (i = 0; options.excludeRegs[i]; i++)
- {
- if (options.excludeRegs[i] &&
- STRCASECMP (s, options.excludeRegs[i]) == 0)
- return TRUE;
- }
- return FALSE;
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* shift left accumulator */
+ AccLsh(left,offl,shCount);
+ /* or with result */
+ emitpcode (POC_IORWF, popGet (AOP(result), offr));
+ assert ( !"broken (modifies left, fails for left==result))" );
}
/*-----------------------------------------------------------------*/
-/* genFunction - generated code for function entry */
+/* shiftRLeftOrResult - shift right one byte from left,or to result*/
/*-----------------------------------------------------------------*/
-static void
-genFunction (iCode * ic)
+static void shiftRLeftOrResult (operand *left, int offl,
+ operand *result, int offr, int shCount)
{
- symbol *sym;
- sym_link *fetype;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- labelOffset += FUNCTION_LABEL_INC;
-
- _G.nRegsSaved = 0;
- /* create the function header */
- emitcode (";", "-----------------------------------------");
- emitcode (";", " function %s", (sym = OP_SYMBOL (IC_LEFT (ic)))->name);
- emitcode (";", "-----------------------------------------");
-
- emitcode ("", "%s:", sym->rname);
- fetype = getSpec (operandType (IC_LEFT (ic)));
-
- /* if critical function then turn interrupts off */
- if (SPEC_CRTCL (fetype))
- emitcode ("clr", "ea");
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* shift right accumulator */
+ AccRsh(left,offl,shCount);
+ /* or with result */
+ emitpcode (POC_IORWF, popGet (AOP(result), offr));
+ assert ( !"broken (modifies left, fails for left==result))" );
+}
- /* here we need to generate the equates for the
- register bank if required */
-#if 0
- if (SPEC_BANK (fetype) != rbank)
- {
- int i;
+/*-----------------------------------------------------------------*/
+/* genlshOne - left shift a one byte quantity by known count */
+/*-----------------------------------------------------------------*/
+static void genlshOne (operand *result, operand *left, int shCount)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shiftL1Left2Result(left, LSB, result, LSB, shCount);
+}
- rbank = SPEC_BANK (fetype);
- for (i = 0; i < pic14_nRegs; i++)
- {
- if (strcmp (regspic14[i].base, "0") == 0)
- emitcode ("", "%s = 0x%02x",
- regspic14[i].dname,
- 8 * rbank + regspic14[i].offset);
- else
- emitcode ("", "%s = %s + 0x%02x",
- regspic14[i].dname,
- regspic14[i].base,
- 8 * rbank + regspic14[i].offset);
+/*-----------------------------------------------------------------*/
+/* genlshTwo - left shift two bytes by known amount != 0 */
+/*-----------------------------------------------------------------*/
+static void genlshTwo (operand *result,operand *left, int shCount)
+{
+ int size;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ size = pic14_getDataSize(result);
+
+ /* if shCount >= 8 */
+ if (shCount >= 8) {
+ shCount -= 8 ;
+
+ if (size > 1){
+ if (shCount)
+ shiftL1Left2Result(left, LSB, result, MSB16, shCount);
+ else
+ movLeft2Result(left, LSB, result, MSB16);
+ }
+ emitpcode(POC_CLRF,popGet(AOP(result),LSB));
}
- }
-#endif
-
- /* if this is an interrupt service routine then
- save acc, b, dpl, dph */
- if (IS_ISR (sym->etype))
- {
-
- if (!inExcludeList ("acc"))
- emitcode ("push", "acc");
- if (!inExcludeList ("b"))
- emitcode ("push", "b");
- if (!inExcludeList ("dpl"))
- emitcode ("push", "dpl");
- if (!inExcludeList ("dph"))
- emitcode ("push", "dph");
- if (options.model == MODEL_FLAT24 && !inExcludeList ("dpx"))
- {
- emitcode ("push", "dpx");
- /* Make sure we're using standard DPTR */
- emitcode ("push", "dps");
- emitcode ("mov", "dps, #0x00");
- if (options.stack10bit)
- {
- /* This ISR could conceivably use DPTR2. Better save it. */
- emitcode ("push", "dpl1");
- emitcode ("push", "dph1");
- emitcode ("push", "dpx1");
- }
+
+ /* 1 <= shCount <= 7 */
+ else {
+ if(size == 1)
+ shiftL1Left2Result(left, LSB, result, LSB, shCount);
+ else
+ shiftL2Left2Result(left, LSB, result, LSB, shCount);
}
- /* if this isr has no bank i.e. is going to
- run with bank 0 , then we need to save more
- registers :-) */
- if (!SPEC_BANK (sym->etype))
- {
-
- /* if this function does not call any other
- function then we can be economical and
- save only those registers that are used */
- if (!sym->hasFcall)
- {
- int i;
+}
- /* if any registers used */
- if (sym->regsUsed)
- {
- /* save the registers used */
- for (i = 0; i < sym->regsUsed->size; i++)
- {
- if (bitVectBitValue (sym->regsUsed, i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
- emitcode ("push", "%s", pic14_regWithIdx (i)->dname);
- }
+/*-----------------------------------------------------------------*/
+/* shiftLLong - shift left one long from left to result */
+/* offl = LSB or MSB16 */
+/*-----------------------------------------------------------------*/
+static void shiftLLong (operand *left, operand *result, int offr )
+{
+ char *l;
+ int size = AOP_SIZE(result);
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(size >= LSB+offr){
+ l = aopGet(AOP(left),LSB,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("add","a,acc");
+ if (pic14_sameRegs(AOP(left),AOP(result)) &&
+ size >= MSB16+offr && offr != LSB )
+ pic14_emitcode("xch","a,%s",
+ aopGet(AOP(left),LSB+offr,FALSE,FALSE));
+ else
+ aopPut(AOP(result),"a",LSB+offr);
+ }
+
+ if(size >= MSB16+offr){
+ if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) {
+ l = aopGet(AOP(left),MSB16,FALSE,FALSE);
+ MOVA(l);
}
-
- }
- else
- {
- /* this function has a function call cannot
- determines register usage so we will have the
- entire bank */
- saverbank (0, ic, FALSE);
- }
+ pic14_emitcode("rlc","a");
+ if (pic14_sameRegs(AOP(left),AOP(result)) &&
+ size >= MSB24+offr && offr != LSB)
+ pic14_emitcode("xch","a,%s",
+ aopGet(AOP(left),MSB16+offr,FALSE,FALSE));
+ else
+ aopPut(AOP(result),"a",MSB16+offr);
+ }
+
+ if(size >= MSB24+offr){
+ if (!(pic14_sameRegs(AOP(left),AOP(left)) && size >= MSB24+offr && offr != LSB)) {
+ l = aopGet(AOP(left),MSB24,FALSE,FALSE);
+ MOVA(l);
+ }
+ pic14_emitcode("rlc","a");
+ if (pic14_sameRegs(AOP(left),AOP(result)) &&
+ size >= MSB32+offr && offr != LSB )
+ pic14_emitcode("xch","a,%s",
+ aopGet(AOP(left),MSB24+offr,FALSE,FALSE));
+ else
+ aopPut(AOP(result),"a",MSB24+offr);
+ }
+
+ if(size > MSB32+offr){
+ if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB32+offr && offr != LSB)) {
+ l = aopGet(AOP(left),MSB32,FALSE,FALSE);
+ MOVA(l);
+ }
+ pic14_emitcode("rlc","a");
+ aopPut(AOP(result),"a",MSB32+offr);
}
- }
- else
- {
- /* if callee-save to be used for this function
- then save the registers being used in this function */
- if (sym->calleeSave)
- {
- int i;
+ if(offr != LSB)
+ aopPut(AOP(result),zero,LSB);
+}
- /* if any registers used */
- if (sym->regsUsed)
- {
- /* save the registers used */
- for (i = 0; i < sym->regsUsed->size; i++)
- {
- if (bitVectBitValue (sym->regsUsed, i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
- {
- emitcode ("push", "%s", pic14_regWithIdx (i)->dname);
- _G.nRegsSaved++;
- }
+/*-----------------------------------------------------------------*/
+/* genlshFour - shift four byte by a known amount != 0 */
+/*-----------------------------------------------------------------*/
+static void genlshFour (operand *result, operand *left, int shCount)
+{
+ int size;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ size = AOP_SIZE(result);
+
+ /* if shifting more that 3 bytes */
+ if (shCount >= 24 ) {
+ shCount -= 24;
+ if (shCount)
+ /* lowest order of left goes to the highest
+ order of the destination */
+ shiftL1Left2Result(left, LSB, result, MSB32, shCount);
+ else
+ movLeft2Result(left, LSB, result, MSB32);
+ aopPut(AOP(result),zero,LSB);
+ aopPut(AOP(result),zero,MSB16);
+ aopPut(AOP(result),zero,MSB32);
+ return;
+ }
+
+ /* more than two bytes */
+ else if ( shCount >= 16 ) {
+ /* lower order two bytes goes to higher order two bytes */
+ shCount -= 16;
+ /* if some more remaining */
+ if (shCount)
+ shiftL2Left2Result(left, LSB, result, MSB24, shCount);
+ else {
+ movLeft2Result(left, MSB16, result, MSB32);
+ movLeft2Result(left, LSB, result, MSB24);
+ }
+ aopPut(AOP(result),zero,MSB16);
+ aopPut(AOP(result),zero,LSB);
+ return;
+ }
+
+ /* if more than 1 byte */
+ else if ( shCount >= 8 ) {
+ /* lower order three bytes goes to higher order three bytes */
+ shCount -= 8;
+ if(size == 2){
+ if(shCount)
+ shiftL1Left2Result(left, LSB, result, MSB16, shCount);
+ else
+ movLeft2Result(left, LSB, result, MSB16);
+ }
+ else{ /* size = 4 */
+ if(shCount == 0){
+ movLeft2Result(left, MSB24, result, MSB32);
+ movLeft2Result(left, MSB16, result, MSB24);
+ movLeft2Result(left, LSB, result, MSB16);
+ aopPut(AOP(result),zero,LSB);
+ }
+ else if(shCount == 1)
+ shiftLLong(left, result, MSB16);
+ else{
+ shiftL2Left2Result(left, MSB16, result, MSB24, shCount);
+ shiftL1Left2Result(left, LSB, result, MSB16, shCount);
+ shiftRLeftOrResult(left, LSB, result, MSB24, 8 - shCount);
+ aopPut(AOP(result),zero,LSB);
+ }
}
- }
}
- }
-
- /* set the register bank to the desired value */
- if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
- {
- emitcode ("push", "psw");
- emitcode ("mov", "psw,#0x%02x", (SPEC_BANK (sym->etype) << 3) & 0x00ff);
- }
-
- if (IS_RENT (sym->etype) || options.stackAuto)
- {
-
- if (options.useXstack)
- {
- emitcode ("mov", "r0,%s", spname);
- emitcode ("mov", "a,_bp");
- emitcode ("movx", "@r0,a");
- emitcode ("inc", "%s", spname);
+
+ /* 1 <= shCount <= 7 */
+ else if(shCount <= 2){
+ shiftLLong(left, result, LSB);
+ if(shCount == 2)
+ shiftLLong(result, result, LSB);
}
- else
- {
- /* set up the stack */
- emitcode ("push", "_bp"); /* save the callers stack */
+ /* 3 <= shCount <= 7, optimize */
+ else{
+ shiftL2Left2Result(left, MSB24, result, MSB24, shCount);
+ shiftRLeftOrResult(left, MSB16, result, MSB24, 8 - shCount);
+ shiftL2Left2Result(left, LSB, result, LSB, shCount);
}
- emitcode ("mov", "_bp,%s", spname);
- }
-
- /* adjust the stack for the function */
- 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");
+}
+#endif
+#if 0
+/*-----------------------------------------------------------------*/
+/* genLeftShiftLiteral - left shifting by known count */
+/*-----------------------------------------------------------------*/
+static void genLeftShiftLiteral (operand *left,
+ operand *right,
+ operand *result,
+ iCode *ic)
+{
+ int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+ //int size;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ freeAsmop(right,NULL,ic,TRUE);
+
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ size = getSize(operandType(result));
+
+#if VIEW_SIZE
+ pic14_emitcode("; shift left ","result %d, left %d",size,
+ AOP_SIZE(left));
+#endif
+
+ /* I suppose that the left size >= result size */
+ if(shCount == 0){
+ while(size--){
+ movLeft2Result(left, size, result, size);
+ }
}
- else
- while (i--)
- emitcode ("inc", "sp");
- }
-
- if (sym->xstack)
- {
-
- emitcode ("mov", "a,_spx");
- emitcode ("add", "a,#0x%02x", ((char) sym->xstack & 0xff));
- emitcode ("mov", "_spx,a");
- }
+
+ else if(shCount >= (size * 8))
+ while(size--)
+ aopPut(AOP(result),zero,size);
+ else{
+ switch (size) {
+ case 1:
+ genlshOne (result,left,shCount);
+ break;
+
+ case 2:
+ case 3:
+ genlshTwo (result,left,shCount);
+ break;
+
+ case 4:
+ genlshFour (result,left,shCount);
+ break;
+ }
+ }
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+#endif
+/*-----------------------------------------------------------------*
+* genMultiAsm - repeat assembly instruction for size of register.
+* if endian == 1, then the high byte (i.e base address + size of
+* register) is used first else the low byte is used first;
+*-----------------------------------------------------------------*/
+static void genMultiAsm( PIC_OPCODE poc, operand *reg, int size, int endian)
+{
+
+ int offset = 0;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(!reg)
+ return;
+
+ if(!endian) {
+ endian = 1;
+ } else {
+ endian = -1;
+ offset = size-1;
+ }
+
+ while(size--) {
+ emitpcode(poc, popGet(AOP(reg),offset));
+ offset += endian;
+ }
+
}
+#if 0
/*-----------------------------------------------------------------*/
-/* genEndFunction - generates epilogue for functions */
+/* genLeftShift - generates code for left shifting */
/*-----------------------------------------------------------------*/
-static void
-genEndFunction (iCode * ic)
-{
- symbol *sym = OP_SYMBOL (IC_LEFT (ic));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- if (IS_RENT (sym->etype) || options.stackAuto)
- {
- 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)
- {
- emitcode ("mov", "a,sp");
- emitcode ("add", "a,#0x%02x", ((char) -sym->stack) & 0xff);
- emitcode ("mov", "sp,a");
- }
-
-
- if ((IS_RENT (sym->etype) || options.stackAuto))
- {
- if (options.useXstack)
- {
- emitcode ("mov", "r0,%s", spname);
- emitcode ("movx", "a,@r0");
- emitcode ("mov", "_bp,a");
- emitcode ("dec", "%s", spname);
+static void genLeftShift (iCode *ic)
+{
+ operand *left,*right, *result;
+ int size, offset;
+ unsigned long lit = 0L;
+ char *l;
+ symbol *tlbl , *tlbl1;
+ pCodeOp *pctemp;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ right = IC_RIGHT(ic);
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+
+ aopOp(right,ic,FALSE);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+
+ /* if the shift count is known then do it
+ as efficiently as possible */
+ if (AOP_TYPE(right) == AOP_LIT) {
+ shiftLeft_Left2ResultLit (left, result, (int) floatFromVal (AOP(right)->aopu.aop_lit));
+ return ;
+ }
+
+ /* shift count is unknown then we have to form
+ a loop get the loop count in B : Note: we take
+ only the lower order byte since shifting
+ more that 32 bits make no sense anyway, ( the
+ largest size of an object can be only 32 bits ) */
+
+ /* this code fails for RIGHT == RESULT */
+ assert (!pic14_sameRegs (AOP(right), AOP(result)));
+
+ /* now move the left to the result if they are not the
+ same */
+ if (!pic14_sameRegs(AOP(left),AOP(result)) &&
+ AOP_SIZE(result) > 1) {
+
+ size = AOP_SIZE(result);
+ offset=0;
+ while (size--) {
+ l = aopGet(AOP(left),offset,FALSE,TRUE);
+ if (*l == '@' && (IS_AOP_PREG(result))) {
+
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offset);
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ //aopPut(AOP(result),l,offset);
+ }
+ offset++;
+ }
}
- else
- {
- emitcode ("pop", "_bp");
+
+ if(AOP_TYPE(left) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(left)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ /* if it is only one byte then */
+ if (size == 1) {
+ if(optimized_for_speed && AOP_TYPE(left)!=AOP_LIT) {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ emitpcode(POC_RLFW, popGet(AOP(result),0));
+ emitpcode(POC_ANDLW, popGetLit(0xfe));
+ emitpcode(POC_ADDFW, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ } else {
+
+ tlbl = newiTempLabel(NULL);
+ if (!pic14_sameRegs(AOP(left),AOP(result))) {
+ mov2w (AOP(left), 0);
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ }
+
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+ emitpLabel(tlbl->key);
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ emitpcode(POC_ADDLW, popGetLit(1));
+ emitSKPC;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ }
+ goto release ;
+ }
+
+ if (pic14_sameRegs(AOP(left),AOP(result))) {
+
+ tlbl = newiTempLabel(NULL);
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ genMultiAsm(POC_RRF, result, size,1);
+ emitpLabel(tlbl->key);
+ genMultiAsm(POC_RLF, result, size,0);
+ emitpcode(POC_ADDLW, popGetLit(1));
+ emitSKPC;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ goto release;
}
- }
-
- /* restore the register bank */
- if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
- emitcode ("pop", "psw");
-
- if (IS_ISR (sym->etype))
- {
-
- /* now we need to restore the registers */
- /* if this isr has no bank i.e. is going to
- run with bank 0 , then we need to save more
- registers :-) */
- if (!SPEC_BANK (sym->etype))
- {
+
+ //tlbl = newiTempLabel(NULL);
+ //offset = 0 ;
+ //tlbl1 = newiTempLabel(NULL);
+
+ //reAdjustPreg(AOP(result));
+
+ //pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ //pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ //l = aopGet(AOP(result),offset,FALSE,FALSE);
+ //MOVA(l);
+ //pic14_emitcode("add","a,acc");
+ //aopPut(AOP(result),"a",offset++);
+ //while (--size) {
+ // l = aopGet(AOP(result),offset,FALSE,FALSE);
+ // MOVA(l);
+ // pic14_emitcode("rlc","a");
+ // aopPut(AOP(result),"a",offset++);
+ //}
+ //reAdjustPreg(AOP(result));
+
+ //pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ //pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
+
+ tlbl = newiTempLabel(NULL);
+ tlbl1= newiTempLabel(NULL);
+
+ size = AOP_SIZE(result);
+ offset = 1;
+
+ pctemp = popGetTempReg(); /* grab a temporary working register. */
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+ /* offset should be 0, 1 or 3 */
+ emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
+ emitSKPNZ;
+ emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
+
+ emitpcode(POC_MOVWF, pctemp);
+
+
+ emitpLabel(tlbl->key);
+
+ emitCLRC;
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ while(--size)
+ emitpcode(POC_RLF, popGet(AOP(result),offset++));
+
+ emitpcode(POC_DECFSZ, pctemp);
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ emitpLabel(tlbl1->key);
+
+ popReleaseTempReg(pctemp);
+
+
+release:
+ freeAsmop (right,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+#endif
- /* if this function does not call any other
- function then we can be economical and
- save only those registers that are used */
- if (!sym->hasFcall)
- {
- int i;
+#if 0
+/*-----------------------------------------------------------------*/
+/* genrshOne - right shift a one byte quantity by known count */
+/*-----------------------------------------------------------------*/
+static void genrshOne (operand *result, operand *left,
+ int shCount, int sign)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shiftR1Left2Result(left, LSB, result, LSB, shCount, sign);
+}
- /* if any registers used */
- if (sym->regsUsed)
- {
- /* save the registers used */
- for (i = sym->regsUsed->size; i >= 0; i--)
- {
- if (bitVectBitValue (sym->regsUsed, i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
- emitcode ("pop", "%s", pic14_regWithIdx (i)->dname);
- }
+/*-----------------------------------------------------------------*/
+/* genrshTwo - right shift two bytes by known amount != 0 */
+/*-----------------------------------------------------------------*/
+static void genrshTwo (operand *result,operand *left,
+ int shCount, int sign)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if shCount >= 8 */
+ if (shCount >= 8) {
+ shCount -= 8 ;
+ if (shCount)
+ shiftR1Left2Result(left, MSB16, result, LSB,
+ shCount, sign);
+ else
+ movLeft2Result(left, MSB16, result, LSB);
+
+ emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
+
+ if(sign) {
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
}
-
- }
- else
- {
- /* this function has a function call cannot
- determines register usage so we will have the
- entire bank */
- unsaverbank (0, ic, FALSE);
- }
- }
-
- if (options.model == MODEL_FLAT24 && !inExcludeList ("dpx"))
- {
- if (options.stack10bit)
- {
- emitcode ("pop", "dpx1");
- emitcode ("pop", "dph1");
- emitcode ("pop", "dpl1");
- }
- emitcode ("pop", "dps");
- emitcode ("pop", "dpx");
- }
- if (!inExcludeList ("dph"))
- emitcode ("pop", "dph");
- if (!inExcludeList ("dpl"))
- emitcode ("pop", "dpl");
- if (!inExcludeList ("b"))
- emitcode ("pop", "b");
- if (!inExcludeList ("acc"))
- emitcode ("pop", "acc");
-
- if (SPEC_CRTCL (sym->etype))
- emitcode ("setb", "ea");
-
- /* if debug then send end of function */
-/* if (options.debug && currFunc) { */
- if (currFunc)
- {
- _G.debugLine = 1;
- emitcode (";", "C$%s$%d$%d$%d ==.",
- FileBaseName (ic->filename), currFunc->lastLine,
- ic->level, ic->block);
- if (IS_STATIC (currFunc->etype))
- emitcode (";", "XF%s$%s$0$0 ==.", moduleName, currFunc->name);
- else
- emitcode (";", "XG$%s$0$0 ==.", currFunc->name);
- _G.debugLine = 0;
}
+
+ /* 1 <= shCount <= 7 */
+ else
+ shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
+}
- emitcode ("reti", "");
- }
- else
- {
- if (SPEC_CRTCL (sym->etype))
- emitcode ("setb", "ea");
-
- if (sym->calleeSave)
- {
- int i;
+/*-----------------------------------------------------------------*/
+/* shiftRLong - shift right one long from left to result */
+/* offl = LSB or MSB16 */
+/*-----------------------------------------------------------------*/
+static void shiftRLong (operand *left, int offl,
+ operand *result, int sign)
+{
+ int size, same;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ size = AOP_SIZE(left);
+ if (AOP_SIZE(result) < size) size = AOP_SIZE(result);
+
+ if (sign)
+ emitpcode (POC_RLFW, popGet (AOP(left), AOP_SIZE(left)-1));
+ else
+ emitCLRC;
- /* if any registers used */
- if (sym->regsUsed)
- {
- /* save the registers used */
- for (i = sym->regsUsed->size; i >= 0; i--)
- {
- if (bitVectBitValue (sym->regsUsed, i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
- emitcode ("pop", "%s", pic14_regWithIdx (i)->dname);
- }
- }
+ assert (offl >= 0 && offl < size);
- }
+ same = pic14_sameRegs (AOP(left), AOP(result));
- /* if debug then send end of function */
- if (currFunc)
+ /* perform the shift */
+ while (size--)
{
- _G.debugLine = 1;
- emitcode (";", "C$%s$%d$%d$%d ==.",
- FileBaseName (ic->filename), currFunc->lastLine,
- ic->level, ic->block);
- if (IS_STATIC (currFunc->etype))
- emitcode (";", "XF%s$%s$0$0 ==.", moduleName, currFunc->name);
- else
- emitcode (";", "XG$%s$0$0 ==.", currFunc->name);
- _G.debugLine = 0;
- }
-
- emitcode ("return", "");
- }
+ if (same && !offl) {
+ emitpcode (POC_RRF, popGet (AOP(result), size));
+ } else {
+ emitpcode (POC_RRFW, popGet (AOP(left), size));
+ emitpcode (POC_MOVWF, popGet (AOP(result), size-offl));
+ }
+ } // while
+ addSign (result, AOP_SIZE(left) - offl, sign);
}
/*-----------------------------------------------------------------*/
-/* genRet - generate code for return statement */
+/* genrshFour - shift four byte by a known amount != 0 */
/*-----------------------------------------------------------------*/
-static void
-genRet (iCode * ic)
-{
- int size, offset = 0, pushed = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if we have no return value then
- just generate the "ret" */
- if (!IC_LEFT (ic))
- goto jumpret;
-
- /* we have something to return then
- move the return value into place */
- aopOp (IC_LEFT (ic), ic, FALSE);
- size = AOP_SIZE (IC_LEFT (ic));
-
- while (size--)
- {
- char *l;
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
- {
- /* #NOCHANGE */
- l = aopGet (AOP (IC_LEFT (ic)), offset++,
- FALSE, TRUE);
- emitcode ("push", "%s", l);
- pushed++;
+static void genrshFour (operand *result, operand *left,
+ int shCount, int sign)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if shifting more that 3 bytes */
+ if(shCount >= 24 ) {
+ shCount -= 24;
+ if(shCount)
+ shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
+ else
+ movLeft2Result(left, MSB32, result, LSB);
+
+ addSign(result, MSB16, sign);
+ }
+ else if(shCount >= 16){
+ shCount -= 16;
+ if(shCount)
+ shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
+ else{
+ movLeft2Result(left, MSB24, result, LSB);
+ movLeft2Result(left, MSB32, result, MSB16);
+ }
+ addSign(result, MSB24, sign);
+ }
+ else if(shCount >= 8){
+ shCount -= 8;
+ if(shCount == 1)
+ shiftRLong(left, MSB16, result, sign);
+ else if(shCount == 0){
+ movLeft2Result(left, MSB16, result, LSB);
+ movLeft2Result(left, MSB24, result, MSB16);
+ movLeft2Result(left, MSB32, result, MSB24);
+ addSign(result, MSB32, sign);
+ }
+ else{
+ shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0);
+ shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount);
+ /* the last shift is signed */
+ shiftR1Left2Result(left, MSB32, result, MSB24, shCount, sign);
+ addSign(result, MSB32, sign);
+ }
}
- else
- {
- l = aopGet (AOP (IC_LEFT (ic)), offset,
- FALSE, FALSE);
- if (strcmp (fReturn[offset], l))
- {
- if (((AOP (IC_LEFT (ic))->type) == AOP_IMMD) ||
- ((AOP (IC_LEFT (ic))->type) == AOP_LIT))
- emitcode ("movlw", "%s", l);
- else
- emitcode ("movf", "%s,w", l);
- if (size)
- emitcode ("movwf", "%s", fReturn[offset]);
- offset++;
- }
+ else{ /* 1 <= shCount <= 7 */
+ if(shCount <= 2){
+ shiftRLong(left, LSB, result, sign);
+ if(shCount == 2)
+ shiftRLong(result, LSB, result, sign);
+ }
+ else{
+ shiftR2Left2Result(left, LSB, result, LSB, shCount, 0);
+ shiftLLeftOrResult(left, MSB24, result, MSB16, 8 - shCount);
+ shiftR2Left2Result(left, MSB24, result, MSB24, shCount, sign);
+ }
}
- }
+}
- if (pushed)
- {
- while (pushed)
- {
- pushed--;
- if (strcmp (fReturn[pushed], "a"))
- emitcode ("pop", fReturn[pushed]);
- else
- emitcode ("pop", "acc");
+/*-----------------------------------------------------------------*/
+/* genRightShiftLiteral - right shifting by known count */
+/*-----------------------------------------------------------------*/
+static void genRightShiftLiteral (operand *left,
+ operand *right,
+ operand *result,
+ iCode *ic,
+ int sign)
+{
+ int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+ int lsize,res_size;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ freeAsmop(right,NULL,ic,TRUE);
+
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+#if VIEW_SIZE
+ pic14_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
+ AOP_SIZE(left));
+#endif
+
+ lsize = pic14_getDataSize(left);
+ res_size = pic14_getDataSize(result);
+ /* test the LEFT size !!! */
+
+ /* I suppose that the left size >= result size */
+ if(shCount == 0){
+ while(res_size--)
+ movLeft2Result(left, res_size, result, res_size);
+ }
+
+ else if(shCount >= (lsize * 8)){
+
+ if(res_size == 1) {
+ emitpcode(POC_CLRF, popGet(AOP(result),LSB));
+ if(sign) {
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),LSB));
+ }
+ } else {
+
+ if(sign) {
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ while(res_size--)
+ emitpcode(POC_MOVWF, popGet(AOP(result),res_size));
+
+ } else {
+
+ while(res_size--)
+ emitpcode(POC_CLRF, popGet(AOP(result),res_size));
+ }
+ }
+ } else {
+
+ switch (res_size) {
+ case 1:
+ genrshOne (result,left,shCount,sign);
+ break;
+
+ case 2:
+ genrshTwo (result,left,shCount,sign);
+ break;
+
+ case 4:
+ genrshFour (result,left,shCount,sign);
+ break;
+ default :
+ break;
+ }
+
}
- }
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
-
-jumpret:
- /* generate a jump to the return label
- if the next is not the return statement */
- if (!(ic->next && ic->next->op == LABEL &&
- IC_LABEL (ic->next) == returnLabel))
- emitcode ("goto", "_%05d_DS_", returnLabel->key + 100 + labelOffset);
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+#endif
+#if 0
+/*-----------------------------------------------------------------*/
+/* genSignedRightShift - right shift of signed number */
+/*-----------------------------------------------------------------*/
+static void genSignedRightShift (iCode *ic)
+{
+ operand *right, *left, *result;
+ int size, offset;
+ // char *l;
+ symbol *tlbl, *tlbl1 ;
+ pCodeOp *pctemp;
+
+ //same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+ /* we do it the hard way put the shift count in b
+ and loop thru preserving the sign */
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ right = IC_RIGHT(ic);
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+
+ aopOp(right,ic,FALSE);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+
+ if ( AOP_TYPE(right) == AOP_LIT) {
+ shiftRight_Left2ResultLit (left, result, (int) floatFromVal (AOP(right)->aopu.aop_lit), 1);
+ //genRightShiftLiteral (left,right,result,ic,1);
+ return ;
+ }
+ /* shift count is unknown then we have to form
+ a loop get the loop count in B : Note: we take
+ only the lower order byte since shifting
+ more that 32 bits make no sense anyway, ( the
+ largest size of an object can be only 32 bits ) */
+
+ //pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ //pic14_emitcode("inc","b");
+ //freeAsmop (right,NULL,ic,TRUE);
+ //aopOp(left,ic,FALSE);
+ //aopOp(result,ic,FALSE);
+
+ /* now move the left to the result if they are not the
+ same */
+ if (!pic14_sameRegs(AOP(left),AOP(result)) &&
+ AOP_SIZE(result) > 1) {
+
+ size = AOP_SIZE(result);
+ offset=0;
+ while (size--) {
+ /*
+ l = aopGet(AOP(left),offset,FALSE,TRUE);
+ if (*l == '@' && IS_AOP_PREG(result)) {
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offset);
+ } else
+ aopPut(AOP(result),l,offset);
+ */
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+ offset++;
+ }
+ }
+
+ /* mov the highest order bit to OVR */
+ tlbl = newiTempLabel(NULL);
+ tlbl1= newiTempLabel(NULL);
+
+ size = AOP_SIZE(result);
+ offset = size - 1;
+
+ pctemp = popGetTempReg(); /* grab a temporary working register. */
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+ /* offset should be 0, 1 or 3 */
+ emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
+ emitSKPNZ;
+ emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
+
+ emitpcode(POC_MOVWF, pctemp);
+
+
+ emitpLabel(tlbl->key);
+
+ emitpcode(POC_RLFW, popGet(AOP(result),offset));
+ emitpcode(POC_RRF, popGet(AOP(result),offset));
+
+ while(--size) {
+ emitpcode(POC_RRF, popGet(AOP(result),--offset));
+ }
+
+ emitpcode(POC_DECFSZ, pctemp);
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ emitpLabel(tlbl1->key);
+
+ popReleaseTempReg(pctemp);
+#if 0
+ size = AOP_SIZE(result);
+ offset = size - 1;
+ pic14_emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("rlc","a");
+ pic14_emitcode("mov","ov,c");
+ /* if it is only one byte then */
+ if (size == 1) {
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_emitcode("mov","c,ov");
+ pic14_emitcode("rrc","a");
+ pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+ aopPut(AOP(result),"a",0);
+ goto release ;
+ }
+
+ reAdjustPreg(AOP(result));
+ pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_emitcode("mov","c,ov");
+ while (size--) {
+ l = aopGet(AOP(result),offset,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",offset--);
+ }
+ reAdjustPreg(AOP(result));
+ pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
+release:
+#endif
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(right,NULL,ic,TRUE);
}
+#endif
/*-----------------------------------------------------------------*/
-/* genLabel - generates a label */
+/* loadSignToC - load the operand's sign bit into CARRY */
/*-----------------------------------------------------------------*/
-static void
-genLabel (iCode * ic)
+
+static void loadSignToC (operand *op)
{
- /* special case never generate */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (IC_LABEL (ic) == entryLabel)
- return;
+ FENTRY;
+ assert (op && AOP(op) && AOP_SIZE(op));
- emitcode ("", "_%05d_DS_:", (IC_LABEL (ic)->key + 100 + labelOffset));
+ emitCLRC;
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(op),AOP_SIZE(op)-1,FALSE,FALSE),7,0));
+ emitSETC;
}
/*-----------------------------------------------------------------*/
-/* genGoto - generates a goto */
+/* genRightShift - generate code for right shifting */
/*-----------------------------------------------------------------*/
-//tsd
+static void genGenericShift (iCode *ic, int shiftRight)
+{
+ operand *right, *left, *result;
+ sym_link *retype ;
+ int size;
+ symbol *tlbl, *tlbl1, *inverselbl;
+
+ FENTRY;
+ /* if signed then we do it the hard way preserve the
+ sign bit moving it inwards */
+ retype = getSpec(operandType(IC_RESULT(ic)));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* signed & unsigned types are treated the same : i.e. the
+ signed is NOT propagated inwards : quoting from the
+ ANSI - standard : "for E1 >> E2, is equivalent to division
+ by 2**E2 if unsigned or if it has a non-negative value,
+ otherwise the result is implementation defined ", MY definition
+ is that the sign does not get propagated */
+
+ right = IC_RIGHT(ic);
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+
+ aopOp(right,ic,FALSE);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ /* if the shift count is known then do it
+ as efficiently as possible */
+ if (AOP_TYPE(right) == AOP_LIT) {
+ int lit = (int)floatFromVal (AOP(right)->aopu.aop_lit);
+ if (lit < 0)
+ {
+ lit = -lit;
+ shiftRight = !shiftRight;
+ }
+
+ if (shiftRight)
+ shiftRight_Left2ResultLit (left, result, lit, !SPEC_USIGN(operandType(left)));
+ else
+ shiftLeft_Left2ResultLit (left, result, lit);
+ //genRightShiftLiteral (left,right,result,ic, 0);
+ return ;
+ }
+
+ /* shift count is unknown then we have to form
+ a loop get the loop count in B : Note: we take
+ only the lower order byte since shifting
+ more that 32 bits make no sense anyway, ( the
+ largest size of an object can be only 32 bits ) */
+
+ /* we must not overwrite the shift counter */
+ assert (!pic14_sameRegs(AOP(right),AOP(result)));
+
+ /* now move the left to the result if they are not the
+ same */
+ if (!pic14_sameRegs(AOP(left),AOP(result)))
+ {
+ size = min(AOP_SIZE(result), AOP_SIZE(left));
+ while (size--) {
+ mov2w(AOP(left), size);
+ movwf(AOP(result), size);
+ }
+ addSign (result, AOP_SIZE(left), !SPEC_USIGN(operandType(left)));
+ }
+
+ tlbl = newiTempLabel(NULL);
+ tlbl1= newiTempLabel(NULL);
+ inverselbl = NULL;
+ size = AOP_SIZE(result);
+
+ mov2w(AOP(right),0);
+ if (!SPEC_USIGN(operandType(right)))
+ {
+ inverselbl = newiTempLabel(NULL);
+ /* signed shift count -- invert shift direction for c<0 */
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),7,0));
+ emitpcode(POC_GOTO, popGetLabel(inverselbl->key));
+ } // if
+ emitpcode(POC_SUBLW, popGetLit(0)); /* -count in WREG, 0-x > 0 --> BORROW = !CARRY --> CARRY is clear! */
+ /* check for `a = b >> c' with `-c == 0' */
+ emitSKPNZ;
+ emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
+ emitpLabel(tlbl->key);
+ /* propagate the sign bit inwards for SIGNED result */
+ if (shiftRight && !SPEC_USIGN(operandType(result))) loadSignToC(result);
+ genMultiAsm(shiftRight ? POC_RRF : POC_RLF, result, size, shiftRight);
+ emitpcode(POC_ADDLW, popGetLit(1)); /* clears CARRY (unless W==0 afterwards) */
+ emitSKPC;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+
+ if (!SPEC_USIGN(operandType(right)))
+ {
+ symbol *inv_loop = newiTempLabel(NULL);
+
+ shiftRight = !shiftRight; /* invert shift direction */
+
+ /* we came here from the code above -- we are done */
+ emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
+
+ /* emit code for shifting N<0 steps, count is already in W */
+ emitpLabel(inverselbl->key);
+ if (!shiftRight || SPEC_USIGN(operandType(result))) emitCLRC;
+ emitpLabel(inv_loop->key);
+ /* propagate the sign bit inwards for SIGNED result */
+ if (shiftRight && !SPEC_USIGN(operandType(result))) loadSignToC(result);
+ genMultiAsm(shiftRight ? POC_RRF : POC_RLF, result, size, shiftRight);
+ emitpcode(POC_ADDLW, popGetLit(1));
+ emitSKPC;
+ emitpcode(POC_GOTO, popGetLabel(inv_loop->key));
+ } // if
+
+ emitpLabel(tlbl1->key);
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop (right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+
+static void genRightShift (iCode *ic)
+{
+ genGenericShift(ic, 1);
+}
+
+static void genLeftShift (iCode *ic)
+{
+ genGenericShift(ic, 0);
+}
+
+/*-----------------------------------------------------------------*/
+/* SetIrp - Set IRP bit */
+/*-----------------------------------------------------------------*/
+void SetIrp(operand *result) {
+ FENTRY;
+ if (AOP_TYPE(result) == AOP_LIT) {
+ unsigned lit = (unsigned)operandLitValue(result);
+ if (lit&0x100)
+ emitSETIRP;
+ else
+ emitCLRIRP;
+ } else {
+ if (PCOP(AOP(result))->type == PO_LITERAL) {
+ int addrs = PCOL(AOP(result))->lit;
+ if (addrs & 0x100)
+ emitSETIRP;
+ else
+ emitCLRIRP;
+ } else {
+ emitCLRIRP; /* always ensure this is clear as it may have previouly been set */
+ if(AOP_SIZE(result) > 1) {
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),1,FALSE,FALSE),0,0));
+ emitSETIRP;
+ }
+ }
+ }
+}
+
static void
-genGoto (iCode * ic)
+setup_fsr (operand *ptr)
{
- emitcode ("goto", "_%05d_DS_", (IC_LABEL (ic)->key + 100) + labelOffset);
+ mov2w_op(ptr, 0);
+ emitpcode(POC_MOVWF, popCopyReg (&pc_fsr));
+
+ /* also setup-up IRP */
+ SetIrp (ptr);
}
/*-----------------------------------------------------------------*/
-/* findLabelBackwards: walks back through the iCode chain looking */
-/* for the given label. Returns number of iCode instructions */
-/* between that label and given ic. */
-/* Returns zero if label not found. */
+/* emitPtrByteGet - emits code to get a byte into WREG from an */
+/* arbitrary pointer (__code, __data, generic) */
/*-----------------------------------------------------------------*/
-#if 0
-static int
-findLabelBackwards (iCode * ic, int key)
+static void
+emitPtrByteGet (operand *src, int p_type, bool alreadyAddressed)
{
- int count = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- while (ic->prev)
+ FENTRY;
+ switch (p_type)
{
- ic = ic->prev;
- count++;
-
- if (ic->op == LABEL && IC_LABEL (ic)->key == key)
- {
- /* printf("findLabelBackwards = %d\n", count); */
- return count;
- }
+ case POINTER:
+ case FPOINTER:
+ if (!alreadyAddressed) setup_fsr (src);
+ emitpcode(POC_MOVFW, popCopyReg (&pc_fsr));
+ break;
+
+ case CPOINTER:
+ assert( AOP_SIZE(src) == 2 );
+ mov2w_op(src, 0);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
+ mov2w_op(src, 1);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+ emitpcode(POC_MOVLW, popGetLit (GPTRTAG_CODE)); /* GPOINTER tag for __code space */
+ call_libraryfunc ("__gptrget1");
+ break;
+
+ case GPOINTER:
+ assert( AOP_SIZE(src) == 3 );
+ mov2w_op(src, 0);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
+ mov2w_op(src, 1);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+ mov2w_op(src, 2);
+ call_libraryfunc ("__gptrget1");
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ break;
}
-
- return 0;
}
-#endif
+
/*-----------------------------------------------------------------*/
-/* genPlusIncr :- does addition with increment if possible */
+/* emitPtrByteSet - emits code to set a byte from src through a */
+/* pointer register INDF (legacy 8051 uses R0, R1, or DPTR). */
/*-----------------------------------------------------------------*/
-static bool
-genPlusIncr (iCode * ic)
+static void
+emitPtrByteSet (operand *dst, int p_type, bool alreadyAddressed)
{
- unsigned int icount;
- unsigned int size = getDataSize (IC_RESULT (ic));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- DEBUGemitcode ("; ", "result %d, left %d, right %d",
- AOP_TYPE (IC_RESULT (ic)),
- AOP_TYPE (IC_LEFT (ic)),
- AOP_TYPE (IC_RIGHT (ic)));
-
- /* will try to generate an increment */
- /* if the right side is not a literal
- we cannot */
- if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
- return FALSE;
-
- DEBUGemitcode ("; ", "%s %d", __FUNCTION__, __LINE__);
- /* if the literal value of the right hand side
- is greater than 1 then it is faster to add */
- if ((icount = floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 2)
- return FALSE;
-
- /* if increment 16 bits in register */
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
- (icount == 1))
+ FENTRY;
+ switch (p_type)
{
+ case POINTER:
+ case FPOINTER:
+ if (!alreadyAddressed) setup_fsr (dst);
+ emitpcode(POC_MOVWF, popCopyReg (&pc_fsr));
+ break;
+
+ case CPOINTER:
+ assert( !"trying to assign to __code pointer" );
+ break;
+
+ case GPOINTER:
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-2));
+ mov2w_op(dst, 0);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
+ mov2w_op(dst, 1);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+ mov2w_op(dst, 2);
+ call_libraryfunc ("__gptrput1");
+ break;
- int offset = MSB16;
-
- emitcode ("incf", "%s,f", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
-
- while (--size)
- {
- emitSKPNZ;
- emitcode (" incf", "%s,f", aopGet (AOP (IC_RESULT (ic)), offset++, FALSE, FALSE));
- }
-
- return TRUE;
+ default:
+ assert( !"unhandled pointer type" );
+ break;
}
+}
- DEBUGemitcode ("; ", "%s %d", __FUNCTION__, __LINE__);
- /* if left is in accumulator - probably a bit operation */
- if (strcmp (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE), "a") &&
- (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY))
- {
+/*-----------------------------------------------------------------*/
+/* genUnpackBits - generates code for unpacking bits */
+/*-----------------------------------------------------------------*/
+static void genUnpackBits (operand *result, operand *left, int ptype, iCode *ifx)
+{
+ int rsize; /* result size */
+ sym_link *etype; /* bitfield type information */
+ int blen; /* bitfield length */
+ int bstr; /* bitfield starting bit within byte */
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ etype = getSpec(operandType(result));
+ rsize = getSize (operandType (result));
+ blen = SPEC_BLEN (etype);
+ bstr = SPEC_BSTR (etype);
- emitcode ("bcf", "(%s >> 3), (%s & 7)",
- AOP (IC_RESULT (ic))->aopu.aop_dir,
- AOP (IC_RESULT (ic))->aopu.aop_dir);
- if (icount)
- emitcode ("xorlw", "1");
+ /* single bit field case */
+ if (blen == 1) {
+ if (ifx) { /* that is for an if statement */
+ pCodeOp *pcop;
+ resolvedIfx rIfx;
+ resolveIfx(&rIfx,ifx);
+ if (ptype == -1) /* direct */
+ pcop = newpCodeOpBit(aopGet (AOP(left),0,FALSE,FALSE),bstr,0);
else
- emitcode ("andlw", "1");
-
- emitSKPZ;
- emitcode ("bsf", "(%s >> 3), (%s & 7)",
- AOP (IC_RESULT (ic))->aopu.aop_dir,
- AOP (IC_RESULT (ic))->aopu.aop_dir);
+ pcop = newpCodeOpBit(pc_indf.pcop.name,bstr,0);
+ emitpcode((rIfx.condition) ? POC_BTFSC : POC_BTFSS,pcop);
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+ ifx->generated=1;
+ } else {
+ int i;
+ assert (!pic14_sameRegs (AOP(result), AOP(left)));
+ for (i=0; i < AOP_SIZE(result); i++)
+ emitpcode (POC_CLRF, popGet (AOP(result), i));
- return TRUE;
+ switch (ptype)
+ {
+ case -1:
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet (AOP(left),0,FALSE,FALSE),bstr,0));
+ /* adjust result below */
+ break;
+
+ case POINTER:
+ case FPOINTER:
+ case GPOINTER:
+ case CPOINTER:
+ emitPtrByteGet (left, ptype, FALSE);
+ emitpcode(POC_ANDLW, popGetLit (1UL << bstr));
+ emitSKPZ;
+ /* adjust result below */
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ } // switch
+
+ /* move sign-/zero extended bit to result */
+ if (SPEC_USIGN(OP_SYM_ETYPE(left))) {
+ emitpcode (POC_INCF, popGet (AOP(result), 0));
+ } else {
+ emitpcode (POC_DECF, popGet (AOP(result), 0));
+ }
+ addSign (result, 1, !SPEC_USIGN(OP_SYM_ETYPE(left)));
}
+ return;
+ }
+ else if (blen <= 8 && ((blen + bstr) <= 8))
+ {
+ /* blen > 1 */
+ int i;
+ for (i=0; i < AOP_SIZE(result); i++)
+ emitpcode (POC_CLRF, popGet (AOP(result), i));
-
- /* if the sizes are greater than 1 then we cannot */
- if (AOP_SIZE (IC_RESULT (ic)) > 1 ||
- AOP_SIZE (IC_LEFT (ic)) > 1)
- return FALSE;
-
- /* If we are incrementing the same register by two: */
-
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
+ switch (ptype)
{
+ case -1:
+ mov2w(AOP(left), 0);
+ break;
+
+ case POINTER:
+ case FPOINTER:
+ case GPOINTER:
+ case CPOINTER:
+ emitPtrByteGet (left, ptype, FALSE);
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ } // switch
- while (icount--)
- emitcode ("incf", "%s,f", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+ if (blen < 8)
+ emitpcode(POC_ANDLW, popGetLit ((((1UL << blen)-1) << bstr) & 0x00ff));
+ movwf(AOP(result), 0);
+ AccRsh (popGet(AOP(result), 0), bstr, 1); /* zero extend the bitfield */
- return TRUE;
+ if (!SPEC_USIGN(OP_SYM_ETYPE(left)) && (bstr + blen != 8))
+ {
+ /* signed bitfield */
+ assert (bstr + blen > 0);
+ emitpcode(POC_MOVLW, popGetLit (0x00ff << (bstr + blen)));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE), bstr + blen - 1, 0));
+ emitpcode(POC_IORWF, popGet(AOP(result),0));
}
+ addSign (result, 1, !SPEC_USIGN(OP_SYM_ETYPE(left)));
+ return;
+ }
- DEBUGemitcode ("; ", "couldn't increment result-%s left-%s",
- aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE),
- aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- return FALSE;
+ assert( !"bitfields larger than 8 bits or crossing byte boundaries are not yet supported" );
}
+#if 1
/*-----------------------------------------------------------------*/
-/* outBitAcc - output a bit in acc */
+/* genDataPointerGet - generates code when ptr offset is known */
/*-----------------------------------------------------------------*/
-static void
-outBitAcc (operand * result)
-{
- symbol *tlbl = newiTempLabel (NULL);
- /* if the result is a bit */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- if (AOP_TYPE (result) == AOP_CRY)
- {
- aopPut (AOP (result), "a", 0);
- }
- else
- {
- emitcode ("jz", "%05d_DS_", tlbl->key + 100);
- emitcode ("mov", "a,%s", one);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- outAcc (result);
- }
+static void genDataPointerGet (operand *left,
+ operand *result,
+ iCode *ic)
+{
+ int size , offset = 0;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ /* optimization - most of the time, left and result are the same
+ * address, but different types. for the pic code, we could omit
+ * the following
+ */
+ aopOp(result,ic,TRUE);
+
+ if (pic14_sameRegs (AOP(left), AOP(result)))
+ return;
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ //emitpcode(POC_MOVFW, popGet(AOP(left),0));
+
+ size = AOP_SIZE(result);
+ if (size > getSize(OP_SYM_ETYPE(left))) size = getSize(OP_SYM_ETYPE(left));
+
+ offset = 0;
+ while (size--) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ offset++;
+ }
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
+#endif
/*-----------------------------------------------------------------*/
-/* genPlusBits - generates code for addition of two bits */
-/*-----------------------------------------------------------------*/
-static void
-genPlusBits (iCode * ic)
-{
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /*
- The following block of code will add two bits.
- Note that it'll even work if the destination is
- the carry (C in the status register).
- It won't work if the 'Z' bit is a source or destination.
- */
-
- /* If the result is stored in the accumulator (w) */
- if (strcmp (aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE), "a") == 0)
- {
- emitcode ("movlw", "(1 << (%s & 7))",
- AOP (IC_RESULT (ic))->aopu.aop_dir,
- AOP (IC_RESULT (ic))->aopu.aop_dir);
- emitcode ("bcf", "(%s >> 3), (%s & 7)",
- AOP (IC_RESULT (ic))->aopu.aop_dir,
- AOP (IC_RESULT (ic))->aopu.aop_dir);
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode ("xorwf", "(%s >>3),f",
- AOP (IC_RESULT (ic))->aopu.aop_dir);
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_LEFT (ic))->aopu.aop_dir,
- AOP (IC_LEFT (ic))->aopu.aop_dir);
- emitcode ("xorwf", "(%s>>3),f",
- AOP (IC_RESULT (ic))->aopu.aop_dir);
- }
- else
- {
-
- emitcode ("clrw", "");
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode ("xorlw", "1");
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_LEFT (ic))->aopu.aop_dir,
- AOP (IC_LEFT (ic))->aopu.aop_dir);
- emitcode ("xorlw", "1");
- }
+/* genNearPointerGet - pic14_emitcode for near pointer fetch */
+/*-----------------------------------------------------------------*/
+static void genNearPointerGet (operand *left,
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ sym_link *ltype = operandType(left);
+ sym_link *rtype = operandType(result);
+ sym_link *retype= getSpec(rtype); /* bitfield type information */
+ int direct = 0;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ aopOp(left,ic,FALSE);
+
+ /* if left is rematerialisable and
+ result is not bit variable type and
+ the left is pointer to data space i.e
+ lower 128 bytes of space */
+ if (AOP_TYPE(left) == AOP_PCODE && //AOP_TYPE(left) == AOP_IMMD &&
+ !IS_BITVAR(retype) &&
+ PIC_IS_DATA_PTR(ltype)) {
+ genDataPointerGet (left,result,ic);
+ return ;
+ }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp (result,ic,FALSE);
+
+ /* Check if can access directly instead of via a pointer */
+ if ((PCOP(AOP(left))->type == PO_LITERAL || PCOP(AOP(left))->type == PO_IMMEDIATE)
+ && AOP_SIZE(result) == 1)
+ {
+ direct = 1;
+ }
+
+ if (IS_BITFIELD(getSpec(operandType(result))))
+ {
+ genUnpackBits (result,left,direct?-1:POINTER,ifxForOp(IC_RESULT(ic),ic));
+ goto release;
+ }
+
+ /* If the pointer value is not in a the FSR then need to put it in */
+ /* Must set/reset IRP bit for use with FSR. */
+ if (!direct)
+ setup_fsr (left);
+
+// sym_link *etype;
+ /* if bitfield then unpack the bits */
+ {
+ /* we have can just get the values */
+ int size = AOP_SIZE(result);
+ int offset = 0 ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ while(size--) {
+ if (direct)
+ emitpcode(POC_MOVWF,popGet(AOP(left),0));
+ else
+ emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
+ if (AOP_TYPE(result) == AOP_LIT) {
+ emitpcode(POC_MOVLW,popGet(AOP(result),offset));
+ } else {
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ }
+ if (size && !direct)
+ emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ offset++;
+ }
+ }
+
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
+ /* we did not allocate which means left
+ already in a pointer register, then
+ if size > 0 && this could be used again
+ we have to point it back to where it
+ belongs */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (AOP_SIZE(result) > 1 &&
+ !OP_SYMBOL(left)->remat &&
+ ( OP_SYMBOL(left)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(result) - 1;
+ while (size--)
+ emitpcode(POC_DECF, popCopyReg(&pc_fsr));
+ }
+ }
+
+release:
+ /* done */
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
#if 0
-/* This is the original version of this code.
-
- * This is being kept around for reference,
- * because I am not entirely sure I got it right...
- */
-static void
-adjustArithmeticResult (iCode * ic)
-{
- if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
- AOP_SIZE (IC_LEFT (ic)) == 3 &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_LEFT (ic)), 2, FALSE, FALSE),
- 2);
-
- if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
- AOP_SIZE (IC_RIGHT (ic)) == 3 &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_RIGHT (ic)), 2, FALSE, FALSE),
- 2);
-
- if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
- AOP_SIZE (IC_LEFT (ic)) < 3 &&
- AOP_SIZE (IC_RIGHT (ic)) < 3 &&
- !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, 2);
- }
+/*-----------------------------------------------------------------*/
+/* genPagedPointerGet - pic14_emitcode for paged pointer fetch */
+/*-----------------------------------------------------------------*/
+static void genPagedPointerGet (operand *left,
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ regs *preg = NULL ;
+ char *rname ;
+ sym_link *rtype, *retype;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ rtype = operandType(result);
+ retype= getSpec(rtype);
+
+ aopOp(left,ic,FALSE);
+
+ /* if the value is already in a pointer register
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(left))) {
+ /* otherwise get a free pointer register */
+ aop = newAsmop(0);
+ preg = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,%s",
+ preg->name,
+ aopGet(AOP(left),0,FALSE,TRUE));
+ rname = preg->name ;
+ } else
+ rname = aopGet(AOP(left),0,FALSE,FALSE);
+
+ freeAsmop(left,NULL,ic,TRUE);
+ aopOp (result,ic,FALSE);
+
+ /* if bitfield then unpack the bits */
+ if (IS_BITFIELD(retype))
+ genUnpackBits (result,left,rname,PPOINTER,0);
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(result);
+ int offset = 0 ;
+
+ while (size--) {
+
+ pic14_emitcode("movx","a,@%s",rname);
+ aopPut(AOP(result),"a",offset);
+
+ offset++ ;
+
+ if (size)
+ pic14_emitcode("inc","%s",rname);
+ }
+ }
+
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
+ /* we did not allocate which means left
+ already in a pointer register, then
+ if size > 0 && this could be used again
+ we have to point it back to where it
+ belongs */
+ if (AOP_SIZE(result) > 1 &&
+ !OP_SYMBOL(left)->remat &&
+ ( OP_SYMBOL(left)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(result) - 1;
+ while (size--)
+ pic14_emitcode("dec","%s",rname);
+ }
+ }
+
+ /* done */
+ freeAsmop(result,NULL,ic,TRUE);
+
+
}
-//#else
-/* This is the pure and virtuous version of this code.
- * I'm pretty certain it's right, but not enough to toss the old
- * code just yet...
- */
-static void
-adjustArithmeticResult (iCode * ic)
-{
- if (opIsGptr (IC_RESULT (ic)) &&
- opIsGptr (IC_LEFT (ic)) &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
- {
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1);
- }
-
- if (opIsGptr (IC_RESULT (ic)) &&
- opIsGptr (IC_RIGHT (ic)) &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
- {
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1);
- }
- if (opIsGptr (IC_RESULT (ic)) &&
- AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE &&
- AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE &&
- !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);
- }
+/*-----------------------------------------------------------------*/
+/* genFarPointerGet - gget value from far space */
+/*-----------------------------------------------------------------*/
+static void genFarPointerGet (operand *left,
+ operand *result, iCode *ic)
+{
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(result));
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(left,ic,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 this is remateriazable */
+ if (AOP_TYPE(left) == AOP_IMMD)
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
+ else { /* we need to get it byte by byte */
+ pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
+ pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
+ if (options.model == MODEL_FLAT24)
+ {
+ pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
+ }
+ }
+ }
+ /* so dptr know contains the address */
+ freeAsmop(left,NULL,ic,TRUE);
+ aopOp(result,ic,FALSE);
+
+ /* if bit then unpack */
+ if (IS_BITFIELD(retype))
+ genUnpackBits(result,left,"dptr",FPOINTER,0);
+ else {
+ size = AOP_SIZE(result);
+ offset = 0 ;
+
+ while (size--) {
+ pic14_emitcode("movx","a,@dptr");
+ aopPut(AOP(result),"a",offset++);
+ if (size)
+ pic14_emitcode("inc","dptr");
+ }
+ }
+
+ freeAsmop(result,NULL,ic,TRUE);
}
#endif
+#if 0
+/*-----------------------------------------------------------------*/
+/* genCodePointerGet - get value from code space */
+/*-----------------------------------------------------------------*/
+static void genCodePointerGet (operand *left,
+ operand *result, iCode *ic)
+{
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(result));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(left,ic,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 this is remateriazable */
+ if (AOP_TYPE(left) == AOP_IMMD)
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
+ else { /* we need to get it byte by byte */
+ pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
+ pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
+ if (options.model == MODEL_FLAT24)
+ {
+ pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
+ }
+ }
+ }
+ /* so dptr know contains the address */
+ freeAsmop(left,NULL,ic,TRUE);
+ aopOp(result,ic,FALSE);
+
+ /* if bit then unpack */
+ if (IS_BITFIELD(retype))
+ genUnpackBits(result,left,"dptr",CPOINTER,0);
+ else {
+ size = AOP_SIZE(result);
+ offset = 0 ;
+
+ while (size--) {
+ pic14_emitcode("clr","a");
+ pic14_emitcode("movc","a,@a+dptr");
+ aopPut(AOP(result),"a",offset++);
+ if (size)
+ pic14_emitcode("inc","dptr");
+ }
+ }
+
+ freeAsmop(result,NULL,ic,TRUE);
+}
+#endif
/*-----------------------------------------------------------------*/
-/* genPlus - generates code for addition */
+/* genGenPointerGet - gget value from generic pointer space */
/*-----------------------------------------------------------------*/
-static void
-genPlus (iCode * ic)
+static void genGenPointerGet (operand *left,
+ operand *result, iCode *ic)
{
- int size, offset = 0;
-
- /* special cases :- */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp (IC_LEFT (ic), ic, FALSE);
- aopOp (IC_RIGHT (ic), ic, FALSE);
- aopOp (IC_RESULT (ic), ic, TRUE);
-
- /* if literal, literal on the right or
- if left requires ACC or right is already
- in ACC */
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_LIT)
- {
- operand *t = IC_RIGHT (ic);
- IC_RIGHT (ic) = IC_LEFT (ic);
- IC_LEFT (ic) = t;
- }
-
- /* if both left & right are in bit space */
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
- AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
- {
- genPlusBits (ic);
- goto release;
- }
-
- /* if left in bit space & right literal */
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
- AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
- {
- /* if result in bit space */
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
+ if (IS_BITFIELD(getSpec(operandType(result))))
{
- if ((unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L)
- {
- emitcode ("movlw", "(1 << (%s & 7)) ;%d", AOP (IC_RESULT (ic))->aopu.aop_dir, __LINE__);
- if (!sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_LEFT (ic))->aopu.aop_dir,
- AOP (IC_LEFT (ic))->aopu.aop_dir);
-
- emitcode ("xorwf", "(%s>>3),f", AOP (IC_RESULT (ic))->aopu.aop_dir);
- }
+ genUnpackBits (result, left, GPOINTER, ifxForOp (IC_RESULT(ic), ic));
+ return;
}
- else
+
{
- size = getDataSize (IC_RESULT (ic));
- while (size--)
- {
- MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- emitcode ("addc", "a,#00 ;%d", __LINE__);
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
- }
+ /* emit call to __gptrget */
+ char *func[] = {NULL, "__gptrget1", "__gptrget2", "__gptrget3", "__gptrget4"};
+ int size = AOP_SIZE(result);
+ int idx = 0;
+
+ assert (size > 0 && size <= 4);
+
+ /* pass arguments */
+ assert (AOP_SIZE(left) == 3);
+ mov2w(AOP(left), 0);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
+ mov2w(AOP(left), 1);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+ mov2w(AOP(left), 2);
+ call_libraryfunc (func[size]);
+
+ /* save result */
+ movwf (AOP(result), --size);
+ while (size--) {
+ emitpcode (POC_MOVFW,popRegFromIdx (Gstack_base_addr - idx++));
+ movwf (AOP(result), size);
+ } // while
+ }
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genConstPointerGet - get value from const generic pointer space */
+/*-----------------------------------------------------------------*/
+static void genConstPointerGet (operand *left,
+ operand *result, iCode *ic)
+{
+ //sym_link *retype = getSpec(operandType(result));
+ #if 0
+ symbol *albl, *blbl;//, *clbl;
+ pCodeOp *pcop;
+ #endif
+ PIC_OPCODE poc;
+ int i, size, lit;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ size = AOP_SIZE(result);
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ DEBUGpic14_emitcode ("; "," %d getting const pointer",__LINE__);
+
+ lit = op_isLitLike (left);
+ poc = lit ? POC_MOVLW : POC_MOVFW;
+
+ if (IS_BITFIELD(getSpec(operandType(result))))
+ {
+ genUnpackBits (result, left, lit ? -1 : CPOINTER, ifxForOp (IC_RESULT(ic), ic));
+ goto release;
}
- goto release;
- }
-
- /* if I can do an increment instead
- of add then GOOD for ME */
- if (genPlusIncr (ic) == TRUE)
- goto release;
-
- size = getDataSize (IC_RESULT (ic));
- if (AOP (IC_RIGHT (ic))->type == AOP_LIT)
- {
- /* Add a literal to something else */
- bool know_W = 0;
- unsigned lit = floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- unsigned l1 = 0;
-
- offset = 0;
- DEBUGemitcode (";", "adding lit to something. size %d", size);
- while (size--)
{
+ char *func[] = { NULL, "__gptrget1", "__gptrget2", "__gptrget3", "__gptrget4" };
+ int size = min(getSize(OP_SYM_ETYPE(left)), AOP_SIZE(result));
+ assert (size > 0 && size <= 4);
+
+ mov2w_op(left, 0);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
+ mov2w_op(left, 1);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+ emitpcode(POC_MOVLW, popGetLit (GPTRTAG_CODE)); /* GPOINTER tag for __code space */
+ call_libraryfunc (func[size]);
- DEBUGemitcode (";", "size %d", size);
-
- switch (lit & 0xff)
- {
- case 0:
- break;
- case 1:
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- emitcode ("incf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- else
- {
- know_W = 0;
- emitcode ("incf", "%s,w", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- if (AOP_TYPE (IC_RESULT (ic)) != AOP_ACC)
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), offset, FALSE, FALSE));
- }
- break;
- case 0xff:
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- emitcode ("decf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- else
+ movwf(AOP(result),size-1);
+ for (i = 1; i < size; i++)
{
- know_W = 0;
- emitcode ("decf", "%s,w", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- if (AOP_TYPE (IC_RESULT (ic)) != AOP_ACC)
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), offset, FALSE, FALSE));
- }
- break;
- default:
- if (!know_W || ((lit & 0xff) != l1))
- {
- know_W = 1;
- emitcode ("movlw", "0x%x", lit & 0xff);
- }
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- else
- {
- know_W = 0;
- emitcode ("addwf", "%s,w", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), offset, FALSE, FALSE));
- if (size)
- {
- emitSKPNC;
- emitcode ("incf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset + 1, FALSE, FALSE));
- }
+ emitpcode(POC_MOVFW, popRegFromIdx (Gstack_base_addr+1-i));
+ movwf(AOP(result),size - 1 - i);
+ } // for
+ }
+
+release:
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
+}
+/*-----------------------------------------------------------------*/
+/* genPointerGet - generate code for pointer get */
+/*-----------------------------------------------------------------*/
+static void genPointerGet (iCode *ic)
+{
+ operand *left, *result ;
+ sym_link *type, *etype;
+ int p_type = -1;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic) ;
+
+ /* depending on the type of pointer we need to
+ move it to the correct pointer register */
+ type = operandType(left);
+ etype = getSpec(type);
+
+ if (IS_PTR_CONST(type))
+ DEBUGpic14_emitcode ("; ***","%d - const pointer",__LINE__);
+
+ /* if left is of type of pointer then it is simple */
+ if (IS_PTR(type) && !IS_FUNC(type->next))
+ p_type = DCL_TYPE(type);
+ else {
+ /* we have to go by the storage class */
+ p_type = PTR_TYPE(SPEC_OCLS(etype));
+
+ DEBUGpic14_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
+
+ if (SPEC_OCLS(etype)->codesp ) {
+ DEBUGpic14_emitcode ("; ***","%d - cpointer",__LINE__);
+ //p_type = CPOINTER ;
}
- }
-
- l1 = lit & 0xff;
- lit >>= 8;
- offset++;
+ else
+ if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged)
+ DEBUGpic14_emitcode ("; ***","%d - fpointer",__LINE__);
+ /*p_type = FPOINTER ;*/
+ else
+ if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged)
+ DEBUGpic14_emitcode ("; ***","%d - ppointer",__LINE__);
+ /* p_type = PPOINTER; */
+ else
+ if (SPEC_OCLS(etype) == idata )
+ DEBUGpic14_emitcode ("; ***","%d - ipointer",__LINE__);
+ /* p_type = IPOINTER; */
+ else
+ DEBUGpic14_emitcode ("; ***","%d - pointer",__LINE__);
+ /* p_type = POINTER ; */
+ }
+
+ /* now that we have the pointer type we assign
+ the pointer values */
+ switch (p_type) {
+
+ case POINTER:
+ case FPOINTER:
+ //case IPOINTER:
+ genNearPointerGet (left,result,ic);
+ break;
+/*
+ case PPOINTER:
+ genPagedPointerGet(left,result,ic);
+ break;
+
+ case FPOINTER:
+ genFarPointerGet (left,result,ic);
+ break;
+*/
+ case CPOINTER:
+ genConstPointerGet (left,result,ic);
+ break;
+
+ case GPOINTER:
+ genGenPointerGet (left,result,ic);
+ break;
+ default:
+ assert ( !"unhandled pointer type" );
+ break;
}
+
+}
- }
- else if (AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
- {
-
- emitcode (";bitadd", "right is bit: %s", aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
- emitcode (";bitadd", "left is bit: %s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- emitcode (";bitadd", "result is bit: %s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
-
- /* here we are adding a bit to a char or int */
- if (size == 1)
- {
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- {
-
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode (" incf", "%s,f", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- }
- else
- {
+/*-----------------------------------------------------------------*/
+/* genPackBits - generates code for packed bit storage */
+/*-----------------------------------------------------------------*/
+static void genPackBits(sym_link *etype,operand *result,operand *right,int p_type)
+{
+ int blen; /* bitfield length */
+ int bstr; /* bitfield starting bit within byte */
+ int litval; /* source literal value (if AOP_LIT) */
+ unsigned char mask; /* bitmask within current byte */
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC)
- {
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode (" xorlw", "1");
- }
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode (" incf", "%s,w", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- }
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_TYPE (IC_RESULT (ic)) != AOP_ACC)
- {
+ blen = SPEC_BLEN (etype);
+ bstr = SPEC_BSTR (etype);
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
- {
- emitcode ("andlw", "1");
- emitcode ("bcf", "(%s >> 3), (%s & 7)",
- AOP (IC_RESULT (ic))->aopu.aop_dir,
- AOP (IC_RESULT (ic))->aopu.aop_dir);
- emitSKPZ;
- emitcode ("bsf", "(%s >> 3), (%s & 7)",
- AOP (IC_RESULT (ic))->aopu.aop_dir,
- AOP (IC_RESULT (ic))->aopu.aop_dir);
-
- }
- else
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- }
- }
+ /* If the bitfield length is less than a byte and does not cross byte boundaries */
+ if ((blen <= 8) && ((bstr + blen) <= 8))
+ {
+ mask = ((unsigned char) (0xFF << (blen + bstr)) |
+ (unsigned char) (0xFF >> (8 - bstr)));
- }
- else
+ if (AOP_TYPE (right) == AOP_LIT)
+ {
+ /* Case with a bitfield length <8 and literal source */
+ int lit = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+ if (blen == 1) {
+ pCodeOp *pcop;
+
+ switch (p_type)
{
- int offset = 1;
-
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- {
- emitcode ("clrz", "");
-
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode (" incf", "%s,f", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
-
- }
+ case -1:
+ if (AOP(result)->type == AOP_PCODE)
+ pcop = newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE),bstr,0);
else
- {
-
- emitcode ("movf", "%s,w", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (ic))->aopu.aop_dir,
- AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode (" incf", "%s,w", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
-
- }
-
- while (--size)
- {
- emitSKPZ;
- emitcode (" incf", "%s,f", aopGet (AOP (IC_RIGHT (ic)), offset++, FALSE, FALSE));
- }
-
- }
-
+ pcop = popGet(AOP(result),0);
+ emitpcode(lit?POC_BSF:POC_BCF,pcop);
+ break;
+
+ case POINTER:
+ case FPOINTER:
+ setup_fsr (result);
+ emitpcode(lit?POC_BSF:POC_BCF,newpCodeOpBit(PCOP(&pc_indf)->name,bstr,0));
+ break;
+
+ case CPOINTER:
+ assert( !"trying to assign to bitfield via pointer to __code space" );
+ break;
+
+ case GPOINTER:
+ emitPtrByteGet(result, p_type, FALSE);
+ if (lit) {
+ emitpcode(POC_IORLW, newpCodeOpLit (1UL << bstr));
+ } else {
+ emitpcode(POC_ANDLW, newpCodeOpLit ((~(1UL << bstr)) & 0x0ff));
+ }
+ emitPtrByteSet(result, p_type, TRUE);
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ break;
+ } // switch (p_type)
+ } else {
+ /* blen > 1 */
+ litval = lit << bstr;
+ litval &= (~mask) & 0x00ff;
+
+ switch (p_type)
+ {
+ case -1:
+ mov2w (AOP(result), 0);
+ if ((litval|mask) != 0x00ff)
+ emitpcode(POC_ANDLW, popGetLit (mask));
+ if (litval != 0x00)
+ emitpcode(POC_IORLW, popGetLit (litval));
+ movwf (AOP(result), 0);
+ break;
+
+ case POINTER:
+ case FPOINTER:
+ case GPOINTER:
+ emitPtrByteGet(result, p_type, FALSE);
+ if ((litval|mask) != 0x00ff)
+ emitpcode(POC_ANDLW, popGetLit (mask));
+ if (litval != 0x00)
+ emitpcode(POC_IORLW, popGetLit (litval));
+ emitPtrByteSet(result, p_type, TRUE);
+ break;
+
+ case CPOINTER:
+ assert( !"trying to assign to bitfield via pointer to __code space" );
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ break;
+ } // switch
+ } // if (blen > 1)
}
- else
+ else
{
-
- if (strcmp (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE), "a") == 0)
- {
- emitcode ("addwf", "%s,w", aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- }
- else
+ /* right is no literal */
+ if (blen==1) {
+ switch (p_type)
{
- //if ( (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) || (AOP_TYPE(IC_RESULT(ic)) == AOP_ACC) )
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC)
- {
- emitcode ("addwf", "%s,w", aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
- if (AOP_TYPE (IC_RESULT (ic)) != AOP_ACC)
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- }
- else
- {
+ case -1:
+ /* Note more efficient code, of pre clearing bit then only setting it if required,
+ * can only be done if it is known that the result is not a SFR */
+ emitpcode(POC_RRFW,popGet(AOP(right),0));
+ emitSKPC;
+ emitpcode(POC_BCF,newpCodeOpBit (aopGet(AOP(result), 0, FALSE, FALSE), bstr, 0));
+ emitSKPNC;
+ emitpcode(POC_BSF,newpCodeOpBit (aopGet(AOP(result), 0, FALSE, FALSE), bstr, 0));
+ break;
+
+ case POINTER:
+ case FPOINTER:
+ case GPOINTER:
+ emitPtrByteGet (result, p_type, FALSE);
+ emitpcode(POC_BTFSS, newpCodeOpBit (aopGet(AOP(right), 0, FALSE, FALSE), bstr, 0));
+ emitpcode(POC_ANDLW, newpCodeOpLit (~(1UL << bstr) & 0x0ff));
+ emitpcode(POC_BTFSC, newpCodeOpBit (aopGet(AOP(right), 0, FALSE, FALSE), bstr, 0));
+ emitpcode(POC_IORLW, newpCodeOpLit ((1UL << bstr) & 0x0ff));
+ emitPtrByteSet (result, p_type, TRUE);
+ break;
+
+ case CPOINTER:
+ assert( !"trying to assign to bitfield via pointer to __code space" );
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ break;
+ } // switch
+ return;
+ } else {
+ /* Case with a bitfield 1 < length <= 8 and arbitrary source */
+ pCodeOp *temp = popGetTempReg ();
+
+ mov2w (AOP(right), 0);
+ if (blen < 8) {
+ emitpcode (POC_ANDLW, popGetLit ((1UL << blen)-1));
+ }
+ emitpcode(POC_MOVWF, temp);
+ if (bstr) {
+ AccLsh (temp, bstr);
+ }
+
+ switch (p_type)
+ {
+ case -1:
+ mov2w (AOP(result), 0);
+ emitpcode(POC_ANDLW, popGetLit (mask));
+ emitpcode(POC_IORFW, temp);
+ movwf (AOP(result), 0);
+ break;
+
+ case POINTER:
+ case FPOINTER:
+ case GPOINTER:
+ emitPtrByteGet (result, p_type, FALSE);
+ emitpcode(POC_ANDLW, popGetLit (mask));
+ emitpcode(POC_IORFW, temp);
+ emitPtrByteSet (result, p_type, TRUE);
+ break;
+
+ case CPOINTER:
+ assert( !"trying to assign to bitfield via pointer to __code space" );
+ break;
+
+ default:
+ assert( !"unhandled pointer type" );
+ break;
+ } // switch
+
+ popReleaseTempReg (temp);
+ } // if (blen > 1)
+ } // if (AOP(right)->type != AOP_LIT)
+ return;
+ } // if (blen <= 8 && ((blen + bstr) <= 8))
- emitcode ("movf", "%s,w", aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
+ assert( !"bitfields larger than 8 bits or crossing byte boundaries are not yet supported" );
+}
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- else
- {
- if ((AOP_TYPE (IC_LEFT (ic)) == AOP_IMMD) ||
- (AOP_TYPE (IC_LEFT (ic)) == AOP_LIT))
- {
- emitcode ("addlw", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- }
- else
- {
- emitcode ("addwf", "%s,w", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- if (AOP_TYPE (IC_RESULT (ic)) != AOP_ACC)
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- }
+/*-----------------------------------------------------------------*/
+/* genDataPointerSet - remat pointer to data space */
+/*-----------------------------------------------------------------*/
+static void genDataPointerSet(operand *right,
+ operand *result,
+ iCode *ic)
+{
+ int size, offset = 0 ;
+ int ressize;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(right,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ assert (IS_SYMOP(result));
+ assert (IS_PTR(OP_SYM_TYPE(result)));
+
+ if (AOP_TYPE(right) == AOP_LIT)
+ size = 4;
+ else
+ size = AOP_SIZE(right);
+ ressize = getSize(OP_SYM_ETYPE(result));
+ if (size > ressize) size = ressize;
+ //fprintf (stderr, "%s:%u: size(right): %d, size(result): %d\n", __FUNCTION__,__LINE__, AOP_SIZE(right), ressize);
+
+ //assert( !"what's going on here?" );
+
+ /*
+ if ( AOP_TYPE(result) == AOP_PCODE) {
+ fprintf(stderr,"genDataPointerSet %s, %d\n",
+ AOP(result)->aopu.pcop->name,
+ PCOI(AOP(result)->aopu.pcop)->offset);
+ }
+ */
+
+ // tsd, was l+1 - the underline `_' prefix was being stripped
+ while (size--) {
+ emitpComment ("%s:%u: size=%d/%d, offset=%d, AOP_TYPE(res)=%d", __FILE__,__LINE__, size, ressize, offset, AOP_TYPE(result));
+
+ if (AOP_TYPE(right) == AOP_LIT) {
+ unsigned int lit = pic14aopLiteral(AOP(IC_RIGHT(ic))->aopu.aop_lit, offset);
+ //fprintf (stderr, "%s:%u: lit %d 0x%x\n", __FUNCTION__,__LINE__, lit, lit);
+ if(lit&0xff) {
+ emitpcode(POC_MOVLW, popGetLit(lit&0xff));
+ emitpcode(POC_MOVWF, popGet(AOP(result), offset));
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(result), offset));
+ }
+ } else {
+ //fprintf (stderr, "%s:%u: no lit\n", __FUNCTION__,__LINE__);
+ emitpcode(POC_MOVFW, popGet(AOP(right), offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result), offset));
}
- }
+
+ offset++;
+ }
+
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNearPointerSet - pic14_emitcode for near pointer put */
+/*-----------------------------------------------------------------*/
+static void genNearPointerSet (operand *right,
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ sym_link *ptype = operandType(result);
+ sym_link *retype = getSpec(operandType(right));
+ sym_link *letype = getSpec(ptype);
+ int direct = 0;
+
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(result,ic,FALSE);
+
+#if 1
+ /* if the result is rematerializable &
+ in data space & not a bit variable */
+ //if (AOP_TYPE(result) == AOP_IMMD &&
+ if (AOP_TYPE(result) == AOP_PCODE &&
+ PIC_IS_DATA_PTR(ptype) &&
+ !IS_BITVAR (retype) &&
+ !IS_BITVAR (letype)) {
+ genDataPointerSet (right,result,ic);
+ freeAsmop(result,NULL,ic,TRUE);
+ return;
}
+#endif
- offset = 1;
- size--;
-
- while (size--)
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(right,ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* Check if can access directly instead of via a pointer */
+ if (PCOP(AOP(result))->type == PO_LITERAL && AOP_SIZE(right) == 1) {
+ direct = 1;
+ }
+
+ if (IS_BITFIELD (letype))
{
- if (!sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- {
- emitcode ("movf", "%s,w", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), offset, FALSE, FALSE));
- }
- emitcode ("movf", "%s,w", aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- emitSKPNC;
- emitcode ("incfsz", "%s,w", aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_RESULT (ic)), offset, FALSE, FALSE));
-
+ genPackBits (letype, result, right, direct?-1:POINTER);
+ return;
+ }
+
+ /* If the pointer value is not in a the FSR then need to put it in */
+ /* Must set/reset IRP bit for use with FSR. */
+ /* Note only do this once - assuming that never need to cross a bank boundary at address 0x100. */
+ if (!direct)
+ setup_fsr (result);
+
+ {
+ /* we have can just get the values */
+ int size = AOP_SIZE(right);
+ int offset = 0 ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ while (size--) {
+ char *l = aopGet(AOP(right),offset,FALSE,TRUE);
+ if (*l == '@' ) {
+ emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
+ } else {
+ if (AOP_TYPE(right) == AOP_LIT) {
+ emitpcode(POC_MOVLW,popGet(AOP(right),offset));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ }
+ if (direct)
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+ else
+ emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+ }
+ if (size && !direct)
+ emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ offset++;
+ }
}
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
+ /* we did not allocate which means left
+ already in a pointer register, then
+ if size > 0 && this could be used again
+ we have to point it back to where it
+ belongs */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (AOP_SIZE(right) > 1 &&
+ !OP_SYMBOL(result)->remat &&
+ ( OP_SYMBOL(result)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(right) - 1;
+ while (size--)
+ emitpcode(POC_DECF, popCopyReg(&pc_fsr));
+ }
+ }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* done */
- }
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
- //adjustArithmeticResult(ic);
+#if 0
+/*-----------------------------------------------------------------*/
+/* genPagedPointerSet - pic14_emitcode for Paged pointer put */
+/*-----------------------------------------------------------------*/
+static void genPagedPointerSet (operand *right,
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ regs *preg = NULL ;
+ char *rname , *l;
+ sym_link *retype;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ retype= getSpec(operandType(right));
+
+ aopOp(result,ic,FALSE);
+
+ /* if the value is already in a pointer register
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(result))) {
+ /* otherwise get a free pointer register */
+ aop = newAsmop(0);
+ preg = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,%s",
+ preg->name,
+ aopGet(AOP(result),0,FALSE,TRUE));
+ rname = preg->name ;
+ } else
+ rname = aopGet(AOP(result),0,FALSE,FALSE);
+
+ freeAsmop(result,NULL,ic,TRUE);
+ aopOp (right,ic,FALSE);
+
+ /* if bitfield then unpack the bits */
+ if (IS_BITFIELD(retype))
+ genPackBits (retype,result,right,rname,PPOINTER);
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(right);
+ int offset = 0 ;
+
+ while (size--) {
+ l = aopGet(AOP(right),offset,FALSE,TRUE);
+
+ MOVA(l);
+ pic14_emitcode("movx","@%s,a",rname);
+
+ if (size)
+ pic14_emitcode("inc","%s",rname);
+
+ offset++;
+ }
+ }
+
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
+ /* we did not allocate which means left
+ already in a pointer register, then
+ if size > 0 && this could be used again
+ we have to point it back to where it
+ belongs */
+ if (AOP_SIZE(right) > 1 &&
+ !OP_SYMBOL(result)->remat &&
+ ( OP_SYMBOL(result)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(right) - 1;
+ while (size--)
+ pic14_emitcode("dec","%s",rname);
+ }
+ }
+
+ /* done */
+ freeAsmop(right,NULL,ic,TRUE);
+
+
+}
-release:
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+/*-----------------------------------------------------------------*/
+/* genFarPointerSet - set value from far space */
+/*-----------------------------------------------------------------*/
+static void genFarPointerSet (operand *right,
+ operand *result, iCode *ic)
+{
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(right));
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(result,ic,FALSE);
+
+ /* 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 this is remateriazable */
+ if (AOP_TYPE(result) == AOP_IMMD)
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE));
+ else { /* we need to get it byte by byte */
+ pic14_emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE));
+ pic14_emitcode("mov","dph,%s",aopGet(AOP(result),1,FALSE,FALSE));
+ if (options.model == MODEL_FLAT24)
+ {
+ pic14_emitcode("mov", "dpx,%s",aopGet(AOP(result),2,FALSE,FALSE));
+ }
+ }
+ }
+ /* so dptr know contains the address */
+ freeAsmop(result,NULL,ic,TRUE);
+ aopOp(right,ic,FALSE);
+
+ /* if bit then unpack */
+ if (IS_BITFIELD(retype))
+ genPackBits(retype,result,right,"dptr",FPOINTER);
+ else {
+ size = AOP_SIZE(right);
+ offset = 0 ;
+
+ while (size--) {
+ char *l = aopGet(AOP(right),offset++,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("movx","@dptr,a");
+ if (size)
+ pic14_emitcode("inc","dptr");
+ }
+ }
+
+ freeAsmop(right,NULL,ic,TRUE);
}
+#endif
/*-----------------------------------------------------------------*/
-/* genMinusDec :- does subtraction with decrement if possible */
+/* genGenPointerSet - set value from generic pointer space */
/*-----------------------------------------------------------------*/
-static bool
-genMinusDec (iCode * ic)
+static void genGenPointerSet (operand *right, operand *result, iCode *ic)
{
- unsigned int icount;
- unsigned int size = getDataSize (IC_RESULT (ic));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* will try to generate an increment */
- /* if the right side is not a literal
- we cannot */
- if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
- return FALSE;
+ sym_link *retype = getSpec(operandType(result));
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(right,ic,FALSE);
+ aopOp(result,ic,FALSE);
- DEBUGemitcode ("; lit val", "%d", (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit));
+
+ DEBUGpic14_AopType(__LINE__,right,NULL,result);
- /* if the literal value of the right hand side
- is greater than 4 then it is not worth it */
- if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 2)
- return FALSE;
-
- /* if decrement 16 bits in register */
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
- (size > 1) &&
- (icount == 1))
- {
-
- if (size == 2)
+ if (IS_BITFIELD(retype))
{
- emitcode ("decf", "%s,f", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
- emitcode ("incfsz", "%s,w", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
- emitcode (" decf", "%s,f", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
+ genPackBits (retype, result, right, GPOINTER);
+ return;
}
- else
+
{
- /* size is 3 or 4 */
- emitcode ("movlw", "0xff");
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
+ /* emit call to __gptrput */
+ char *func[] = {NULL, "__gptrput1", "__gptrput2", "__gptrput3", "__gptrput4"};
+ int size = AOP_SIZE(right);
+ int idx = 0;
- emitSKPNC;
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
- emitSKPNC;
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
+ assert (size == getSize(OP_SYM_ETYPE(result)));
+ assert (size > 0 && size <= 4);
- if (size > 3)
+ /* pass arguments */
+ /* - value (MSB in Gstack_base_addr-2, growing downwards) */
+ {
+ int off = size;
+ idx = 2;
+ while (off--)
{
- emitcode ("skpnc", "");
- emitSKPNC;
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+ mov2w_op (right, off);
+ emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - idx++));
}
-
+ idx = 0;
+ }
+ /* - address */
+ assert (AOP_SIZE(result) == 3);
+ mov2w(AOP(result), 0);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+ mov2w(AOP(result), 1);
+ emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+ mov2w(AOP(result), 2);
+ call_libraryfunc (func[size]);
}
-
- 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)
- return FALSE;
-
- /* we can if the aops of the left & result match or
- if they are in registers and the registers are the
- same */
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
- {
-
- while (icount--)
- emitcode ("decf", "%s,f", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
-
- return TRUE;
- }
-
- DEBUGemitcode ("; returning", " result=%s, left=%s",
- aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE),
- aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- if (size == 1)
- {
- emitcode ("decf", "%s,w", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- return TRUE;
- }
-
- return FALSE;
+
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
-/* addSign - complete with sign */
+/* genPointerSet - stores the value into a pointer location */
/*-----------------------------------------------------------------*/
-static void
-addSign (operand * result, int offset, int sign)
-{
- int size = (getDataSize (result) - offset);
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (size > 0)
- {
- if (sign)
- {
- emitcode ("rlc", "a");
- emitcode ("subb", "a,acc");
- while (size--)
- aopPut (AOP (result), "a", offset++);
+static void genPointerSet (iCode *ic)
+{
+ operand *right, *result ;
+ sym_link *type, *etype;
+ int p_type;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ right = IC_RIGHT(ic);
+ result = IC_RESULT(ic) ;
+
+ /* depending on the type of pointer we need to
+ move it to the correct pointer register */
+ type = operandType(result);
+ etype = getSpec(type);
+ /* if left is of type of pointer then it is simple */
+ if (IS_PTR(type) && !IS_FUNC(type->next)) {
+ p_type = DCL_TYPE(type);
+ }
+ else {
+ /* we have to go by the storage class */
+ p_type = PTR_TYPE(SPEC_OCLS(etype));
+
+ /* if (SPEC_OCLS(etype)->codesp ) { */
+ /* p_type = CPOINTER ; */
+ /* } */
+ /* else */
+ /* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
+ /* p_type = FPOINTER ; */
+ /* else */
+ /* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
+ /* p_type = PPOINTER ; */
+ /* else */
+ /* if (SPEC_OCLS(etype) == idata ) */
+ /* p_type = IPOINTER ; */
+ /* else */
+ /* p_type = POINTER ; */
+ }
+
+ /* now that we have the pointer type we assign
+ the pointer values */
+ switch (p_type) {
+
+ case POINTER:
+ case FPOINTER:
+ //case IPOINTER:
+ genNearPointerSet (right,result,ic);
+ break;
+/*
+ case PPOINTER:
+ genPagedPointerSet (right,result,ic);
+ break;
+
+ case FPOINTER:
+ genFarPointerSet (right,result,ic);
+ break;
+*/
+ case GPOINTER:
+ genGenPointerSet (right,result,ic);
+ break;
+
+ default:
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "genPointerSet: illegal pointer type");
}
- else
- while (size--)
- aopPut (AOP (result), zero, offset++);
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* genMinusBits - generates code for subtraction of two bits */
-/*-----------------------------------------------------------------*/
-static void
-genMinusBits (iCode * ic)
-{
- symbol *lbl = newiTempLabel (NULL);
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
- {
- emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
- emitcode ("jnb", "%s,%05d_DS_", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
- emitcode ("cpl", "c");
- emitcode ("", "%05d_DS_:", (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_DS_", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
- emitcode ("inc", "a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- aopPut (AOP (IC_RESULT (ic)), "a", 0);
- addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
- }
}
/*-----------------------------------------------------------------*/
-/* genMinus - generates code for subtraction */
+/* genIfx - generate code for Ifx statement */
/*-----------------------------------------------------------------*/
-static void
-genMinus (iCode * ic)
-{
- int size, offset = 0;
- unsigned long lit = 0L;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp (IC_LEFT (ic), ic, FALSE);
- aopOp (IC_RIGHT (ic), ic, FALSE);
- aopOp (IC_RESULT (ic), ic, TRUE);
-
- /* special cases :- */
- /* if both left & right are in bit space */
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
- AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
- {
- genMinusBits (ic);
- goto release;
- }
-
- /* if I can do an decrement instead
- of subtract then GOOD for ME */
- if (genMinusDec (ic) == TRUE)
- goto release;
-
- size = getDataSize (IC_RESULT (ic));
-
- if (AOP (IC_RIGHT (ic))->type == AOP_LIT)
- {
- /* Add a literal to something else */
-
- lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- lit = -(long) lit;
-
- /* add the first byte: */
- emitcode ("movlw", "0x%x", lit & 0xff);
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
-
- offset = 1;
- size--;
-
- while (size--)
+static void genIfx (iCode *ic, iCode *popIc)
+{
+ operand *cond = IC_COND(ic);
+ int isbit =0;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(cond,ic,FALSE);
+
+ /* get the value into acc */
+ if (AOP_TYPE(cond) != AOP_CRY)
+ pic14_toBoolean(cond);
+ else
+ isbit = 1;
+
+ /* if there was something to be popped then do it */
+ if (popIc)
+ genIpop(popIc);
+
+ if (isbit)
+ {
+ /* This assumes that CARRY is set iff cond is true */
+ if (IC_TRUE(ic))
+ {
+ assert (!IC_FALSE(ic));
+ emitpcode(POC_BTFSC, popGet(AOP(cond), 0));
+ //emitSKPNC;
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key));
+ } else {
+ assert (IC_FALSE(ic));
+ emitpcode(POC_BTFSS, popGet(AOP(cond), 0));
+ //emitSKPC;
+ emitpcode(POC_GOTO, popGetLabel(IC_FALSE(ic)->key));
+ }
+ if (0)
+ {
+ static int hasWarned = 0;
+ if (!hasWarned)
+ {
+ fprintf (stderr, "WARNING: using untested code for %s:%u -- please check the .asm output and report bugs.\n", ic->filename, ic->lineno);
+ hasWarned = 1;
+ }
+ }
+ }
+ else
{
-
- emitcode ("rlf", "_known_zero,w");
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
-
- lit >>= 8;
- if (lit & 0xff)
- {
- emitcode ("movlw", "0x%x", lit & 0xff);
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
-
- }
- offset++;
+ /* now Z is set iff !cond */
+ if (IC_TRUE(ic))
+ {
+ assert (!IC_FALSE(ic));
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key));
+ } else {
+ emitSKPNZ;
+ emitpcode(POC_GOTO, popGetLabel(IC_FALSE(ic)->key));
+ }
}
+
+ ic->generated = 1;
+
+ /* the result is now in the accumulator */
+ freeAsmop(cond,NULL,ic,TRUE);
+}
- }
- else
- {
-
- emitcode ("movf", "%s", aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
- emitcode ("subwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
+/*-----------------------------------------------------------------*/
+/* genAddrOf - generates code for address of */
+/*-----------------------------------------------------------------*/
+static void genAddrOf (iCode *ic)
+{
+ operand *right, *result, *left;
+ int size, offset ;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ //aopOp(IC_RESULT(ic),ic,FALSE);
+
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+ assert (IS_SYMOP (left));
+
+ /* sanity check: generic pointers to code space are not yet supported,
+ * pionters to codespace must not be assigned addresses of __data values. */
+ #if 0
+ fprintf (stderr, "result: %s, left: %s\n", OP_SYMBOL(result)->name, OP_SYMBOL(left)->name);
+ fprintf (stderr, "result->type : "); printTypeChain (OP_SYM_TYPE(result), stderr); fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE(SPEC_OCLS(getSpec (OP_SYM_TYPE(result)))), IS_CODEPTR(OP_SYM_TYPE(result)), IS_PTR_CONST(OP_SYM_TYPE(result)));
+ fprintf (stderr, "result->etype: "); printTypeChain (OP_SYM_ETYPE(result), stderr); fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE(SPEC_OCLS(getSpec (OP_SYM_ETYPE(result)))), IS_CODEPTR(OP_SYM_ETYPE(result)), IS_PTR_CONST(OP_SYM_ETYPE(result)));
+ fprintf (stderr, "left->type : "); printTypeChain (OP_SYM_TYPE(left), stderr); fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE(SPEC_OCLS(getSpec (OP_SYM_TYPE(left)))), IS_CODEPTR(OP_SYM_TYPE(left)), IS_PTR_CONST(OP_SYM_TYPE(left)));
+ fprintf (stderr, "left->etype : "); printTypeChain (OP_SYM_ETYPE(left), stderr); fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n",IN_CODESPACE(SPEC_OCLS(getSpec (OP_SYM_ETYPE(left)))), IS_CODEPTR(OP_SYM_ETYPE(left)), IS_PTR_CONST(OP_SYM_ETYPE(left)));
+#endif
- offset = 1;
- size--;
+ if (IS_CODEPTR(OP_SYM_TYPE(result)) && !IN_CODESPACE(SPEC_OCLS(getSpec (OP_SYM_TYPE(left))))) {
+ fprintf (stderr, "trying to assign __code pointer (%s) an address in __data space (&%s) -- expect trouble\n",
+ IS_SYMOP(result) ? OP_SYMBOL(result)->name : "unknown",
+ OP_SYMBOL(left)->name);
+ } else if (!IS_CODEPTR (OP_SYM_TYPE(result)) && IN_CODESPACE(SPEC_OCLS(getSpec(OP_SYM_TYPE(left))))) {
+ fprintf (stderr, "trying to assign __data pointer (%s) an address in __code space (&%s) -- expect trouble\n",
+ IS_SYMOP(result) ? OP_SYMBOL(result)->name : "unknown",
+ OP_SYMBOL(left)->name);
+ }
+
+ size = AOP_SIZE(IC_RESULT(ic));
+ if (IS_GENPTR(OP_SYM_TYPE(result))) {
+ /* strip tag */
+ if (size > GPTRSIZE-1) size = GPTRSIZE-1;
+ }
+ offset = 0;
+
+ while (size--) {
+ /* fixing bug #863624, reported from (errolv) */
+ emitpcode(POC_MOVLW, popGetImmd(OP_SYMBOL(left)->rname, offset, 0, IS_FUNC(OP_SYM_TYPE(left))));
+ emitpcode(POC_MOVWF, popGet(AOP(result), offset));
+
+#if 0
+ emitpcode(POC_MOVLW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+#endif
+ offset++;
+ }
- while (size--)
+ if (IS_GENPTR(OP_SYM_TYPE(result)))
{
- emitcode ("movf", "%s,w", aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- emitSKPNC;
- emitcode ("incfsz", "%s,w", aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- emitcode ("subwf", "%s,f", aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
-
+ /* provide correct tag */
+ int isCode = IN_CODESPACE(SPEC_OCLS(getSpec(OP_SYM_TYPE(left))));
+ emitpcode (POC_MOVLW, popGetLit (isCode ? GPTRTAG_CODE : GPTRTAG_DATA));
+ movwf (AOP(result), 2);
}
-
- }
-
-
- // adjustArithmeticResult(ic);
-
-release:
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+
+ freeAsmop(left,NULL,ic,FALSE);
+ freeAsmop(result,NULL,ic,TRUE);
+
}
-
+#if 0
/*-----------------------------------------------------------------*/
-/* genMultbits :- multiplication of bits */
+/* genFarFarAssign - assignment when both are in far space */
/*-----------------------------------------------------------------*/
-static void
-genMultbits (operand * left,
- operand * right,
- operand * result)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
- outBitC (result);
+static void genFarFarAssign (operand *result, operand *right, iCode *ic)
+{
+ int size = AOP_SIZE(right);
+ int offset = 0;
+ char *l ;
+ /* first push the right side on to the stack */
+ while (size--) {
+ l = aopGet(AOP(right),offset++,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode ("push","acc");
+ }
+
+ freeAsmop(right,NULL,ic,FALSE);
+ /* now assign DPTR to result */
+ aopOp(result,ic,FALSE);
+ size = AOP_SIZE(result);
+ while (size--) {
+ pic14_emitcode ("pop","acc");
+ aopPut(AOP(result),"a",--offset);
+ }
+ freeAsmop(result,NULL,ic,FALSE);
+
}
-
+#endif
/*-----------------------------------------------------------------*/
-/* genMultOneByte : 8 bit multiplication & division */
+/* genAssign - generate code for assignment */
/*-----------------------------------------------------------------*/
-static void
-genMultOneByte (operand * left,
- operand * right,
- operand * result)
-{
- sym_link *opetype = operandType (result);
- char *l;
- symbol *lbl;
- int size, offset;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* (if two literals, the value is computed before) */
- /* if one literal, literal on the right */
- if (AOP_TYPE (left) == AOP_LIT)
- {
- operand *t = right;
- right = left;
- left = t;
- }
+static void genAssign (iCode *ic)
+{
+ operand *result, *right;
+ int size, offset,know_W;
+ unsigned long lit = 0L;
+
+ result = IC_RESULT(ic);
+ right = IC_RIGHT(ic) ;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* if they are the same */
+ if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
+ return ;
+
+ aopOp(right,ic,FALSE);
+ aopOp(result,ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* if they are the same registers */
+ if (pic14_sameRegs(AOP(right),AOP(result)))
+ goto release;
- size = AOP_SIZE (result);
- /* signed or unsigned */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("mul", "ab");
- /* if result size = 1, mul signed = mul unsigned */
- aopPut (AOP (result), "a", 0);
- if (size > 1)
- {
- if (SPEC_USIGN (opetype))
+ /* special case: assign from __code */
+ if (!IS_ITEMP(right) /* --> iTemps never reside in __code */
+ && IS_SYMOP (right) /* --> must be an immediate (otherwise we would be in genConstPointerGet) */
+ && !IS_FUNC(OP_SYM_TYPE(right)) /* --> we would want its address instead of the first instruction */
+ && !IS_CODEPTR(OP_SYM_TYPE(right)) /* --> get symbols address instread */
+ && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE(right)))))
{
- aopPut (AOP (result), "b", 1);
- if (size > 2)
- /* for filling the MSBs */
- emitcode ("clr", "a");
+ emitpComment ("genAssign from CODESPACE");
+ genConstPointerGet (right, result, ic);
+ goto release;
}
- else
- {
- emitcode ("mov", "a,b");
-
- /* adjust the MSB if left or right neg */
-
- /* if one literal */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- /* AND literal negative */
- if ((int) floatFromVal (AOP (right)->aopu.aop_lit) < 0)
- {
- /* adjust MSB (c==0 after mul) */
- emitcode ("subb", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
+
+ /* just for symmetry reasons... */
+ if (!IS_ITEMP(result)
+ && IS_SYMOP (result)
+ && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE(result)))))
+ {
+ assert ( !"cannot write to CODESPACE" );
+ }
+
+ /* if the result is a bit */
+ if (AOP_TYPE(result) == AOP_CRY) {
+
+ /* if the right size is a literal then
+ we know what the value is */
+ if (AOP_TYPE(right) == AOP_LIT) {
+
+ emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
+ popGet(AOP(result),0));
+
+ if (((int) operandLitValue(right)))
+ pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ else
+ pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ goto release;
}
- }
- else
- {
- lbl = newiTempLabel (NULL);
- emitcode ("xch", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- emitcode ("cjne", "a,#0x80,%05d_DS_", (lbl->key + 100));
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- emitcode ("xch", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- lbl = newiTempLabel (NULL);
- emitcode ("jc", "%05d_DS_", (lbl->key + 100));
- emitcode ("subb", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- }
-
- lbl = newiTempLabel (NULL);
- emitcode ("xch", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
- emitcode ("cjne", "a,#0x80,%05d_DS_", (lbl->key + 100));
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- emitcode ("xch", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
- lbl = newiTempLabel (NULL);
- emitcode ("jc", "%05d_DS_", (lbl->key + 100));
- emitcode ("subb", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
-
- aopPut (AOP (result), "a", 1);
- if (size > 2)
- {
- /* get the sign */
- emitcode ("rlc", "a");
- emitcode ("subb", "a,acc");
- }
+
+ /* the right is also a bit variable */
+ if (AOP_TYPE(right) == AOP_CRY) {
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3),(%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ goto release ;
+ }
+
+ /* we need to or */
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ pic14_toBoolean(right);
+ emitSKPZ;
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ //aopPut(AOP(result),"a",0);
+ goto release ;
+ }
+
+ /* bit variables done */
+ /* general case */
+ size = AOP_SIZE(result);
+ offset = 0 ;
+ if( AOP_TYPE(right) == AOP_DIR && (AOP_TYPE(result) == AOP_REG) && size==1) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(aopIdx(AOP(result),0) == 4) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ goto release;
+ } else
+ DEBUGpic14_emitcode ("; WARNING","%s %d ignoring register storage",__FUNCTION__,__LINE__);
+ }
+
+ know_W=-1;
+ while (size--) {
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(AOP_TYPE(right) == AOP_LIT) {
+ lit = (unsigned long)pic14aopLiteral(AOP(right)->aopu.aop_lit, offset) & 0x0ff;
+ if(lit&0xff) {
+ if(know_W != (int)(lit&0xff))
+ emitpcode(POC_MOVLW,popGetLit(lit&0xff));
+ know_W = lit&0xff;
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ } else
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+
+ } else if (AOP_TYPE(right) == AOP_CRY) {
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+ if(offset == 0) {
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+ }
+ } else {
+ mov2w_op (right, offset);
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+
+ offset++;
}
- size -= 2;
- offset = 2;
- if (size > 0)
- while (size--)
- aopPut (AOP (result), "a", offset++);
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* genMult - generates code for multiplication */
-/*-----------------------------------------------------------------*/
-static void
-genMult (iCode * ic)
-{
- operand *left = IC_LEFT (ic);
- operand *right = IC_RIGHT (ic);
- operand *result = IC_RESULT (ic);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* assign the amsops */
- aopOp (left, ic, FALSE);
- aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
-
- /* special cases first */
- /* both are bits */
- if (AOP_TYPE (left) == AOP_CRY &&
- AOP_TYPE (right) == AOP_CRY)
- {
- genMultbits (left, right, result);
- goto release;
- }
-
- /* if both are of size == 1 */
- if (AOP_SIZE (left) == 1 &&
- AOP_SIZE (right) == 1)
- {
- genMultOneByte (left, right, result);
- goto release;
- }
-
- /* should have been converted to function call */
- assert (1);
-
+
+
release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
+ freeAsmop (right,NULL,ic,FALSE);
+ freeAsmop (result,NULL,ic,TRUE);
+}
/*-----------------------------------------------------------------*/
-/* genDivbits :- division of bits */
-/*-----------------------------------------------------------------*/
-static void
-genDivbits (operand * left,
- operand * right,
- operand * result)
-{
-
- char *l;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* the result must be bit */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
-
- MOVA (l);
-
- emitcode ("div", "ab");
- emitcode ("rrc", "a");
- aopPut (AOP (result), "c", 0);
-}
-
-/*-----------------------------------------------------------------*/
-/* genDivOneByte : 8 bit division */
+/* genJumpTab - genrates code for jump table */
/*-----------------------------------------------------------------*/
-static void
-genDivOneByte (operand * left,
- operand * right,
- operand * result)
-{
- sym_link *opetype = operandType (result);
- char *l;
- symbol *lbl;
- int size, offset;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- size = AOP_SIZE (result) - 1;
- offset = 1;
- /* signed or unsigned */
- if (SPEC_USIGN (opetype))
- {
- /* unsigned is easy */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("div", "ab");
- aopPut (AOP (result), "a", 0);
- while (size--)
- aopPut (AOP (result), zero, offset++);
- return;
- }
-
- /* signed is a little bit more difficult */
-
- /* save the signs of the operands */
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, TRUE));
- emitcode ("push", "acc"); /* save it on the stack */
-
- /* now sign adjust for both left & right */
- l = aopGet (AOP (right), 0, FALSE, FALSE);
- MOVA (l);
- lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d_DS_", (lbl->key + 100));
- emitcode ("cpl", "a");
- emitcode ("inc", "a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- emitcode ("mov", "b,a");
-
- /* sign adjust left side */
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
-
- lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d_DS_", (lbl->key + 100));
- emitcode ("cpl", "a");
- emitcode ("inc", "a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
-
- /* now the division */
- emitcode ("div", "ab");
- /* we are interested in the lower order
- only */
- emitcode ("mov", "b,a");
- lbl = newiTempLabel (NULL);
- emitcode ("pop", "acc");
- /* if there was an over flow we don't
- adjust the sign of the result */
- emitcode ("jb", "ov,%05d_DS_", (lbl->key + 100));
- emitcode ("jnb", "acc.7,%05d_DS_", (lbl->key + 100));
- CLRC;
- emitcode ("clr", "a");
- emitcode ("subb", "a,b");
- emitcode ("mov", "b,a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
-
- /* now we are done */
- aopPut (AOP (result), "b", 0);
- if (size > 0)
- {
- emitcode ("mov", "c,b.7");
- emitcode ("subb", "a,acc");
- }
- while (size--)
- aopPut (AOP (result), "a", offset++);
-
+static void genJumpTab (iCode *ic)
+{
+ symbol *jtab;
+ char *l;
+
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(IC_JTCOND(ic),ic,FALSE);
+ /* get the condition into accumulator */
+ l = aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE);
+ MOVA(l);
+ /* multiply by three */
+ pic14_emitcode("add","a,acc");
+ pic14_emitcode("add","a,%s",aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE));
+
+ jtab = newiTempLabel(NULL);
+ pic14_emitcode("mov","dptr,#%05d_DS_",jtab->key+100);
+ pic14_emitcode("jmp","@a+dptr");
+ pic14_emitcode("","%05d_DS_:",jtab->key+100);
+
+ emitpcode(POC_MOVLW, popGetHighLabel(jtab->key));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVLW, popGetLabel(jtab->key));
+ emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0));
+ emitSKPNC;
+ emitpcode(POC_INCF, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pcl));
+ emitpLabel(jtab->key);
+
+ freeAsmop(IC_JTCOND(ic),NULL,ic,TRUE);
+
+ /* now generate the jump labels */
+ for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
+ jtab = setNextItem(IC_JTLABELS(ic))) {
+ pic14_emitcode("ljmp","%05d_DS_",jtab->key+100);
+ emitpcode(POC_GOTO,popGetLabel(jtab->key));
+
+ }
+
}
/*-----------------------------------------------------------------*/
-/* genDiv - generates code for division */
+/* genMixedOperation - gen code for operators between mixed types */
/*-----------------------------------------------------------------*/
-static void
-genDiv (iCode * ic)
-{
- operand *left = IC_LEFT (ic);
- operand *right = IC_RIGHT (ic);
- operand *result = IC_RESULT (ic);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* assign the amsops */
- aopOp (left, ic, FALSE);
- aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
-
- /* special cases first */
- /* both are bits */
- if (AOP_TYPE (left) == AOP_CRY &&
- AOP_TYPE (right) == AOP_CRY)
- {
- genDivbits (left, right, result);
- goto release;
- }
-
- /* if both are of size == 1 */
- if (AOP_SIZE (left) == 1 &&
- AOP_SIZE (right) == 1)
- {
- genDivOneByte (left, right, result);
- goto release;
- }
-
- /* should have been converted to function call */
- assert (1);
+/*
+TSD - Written for the PIC port - but this unfortunately is buggy.
+This routine is good in that it is able to efficiently promote
+types to different (larger) sizes. Unfortunately, the temporary
+variables that are optimized out by this routine are sometimes
+used in other places. So until I know how to really parse the
+iCode tree, I'm going to not be using this routine :(.
+*/
+static int genMixedOperation (iCode *ic)
+{
+ FENTRY;
+#if 0
+ operand *result = IC_RESULT(ic);
+ sym_link *ctype = operandType(IC_LEFT(ic));
+ operand *right = IC_RIGHT(ic);
+ int ret = 0;
+ int big,small;
+ int offset;
+
+ iCode *nextic;
+ operand *nextright=NULL,*nextleft=NULL,*nextresult=NULL;
+
+ pic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ nextic = ic->next;
+ if(!nextic)
+ return 0;
+
+ nextright = IC_RIGHT(nextic);
+ nextleft = IC_LEFT(nextic);
+ nextresult = IC_RESULT(nextic);
+
+ aopOp(right,ic,FALSE);
+ aopOp(result,ic,FALSE);
+ aopOp(nextright, nextic, FALSE);
+ aopOp(nextleft, nextic, FALSE);
+ aopOp(nextresult, nextic, FALSE);
+
+ if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_RIGHT(nextic)))) {
+
+ operand *t = right;
+ right = nextright;
+ nextright = t;
+
+ pic14_emitcode(";remove right +","");
+
+ } else if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_LEFT(nextic)))) {
+ /*
+ operand *t = right;
+ right = nextleft;
+ nextleft = t;
+ */
+ pic14_emitcode(";remove left +","");
+ } else
+ return 0;
+
+ big = AOP_SIZE(nextleft);
+ small = AOP_SIZE(nextright);
+
+ switch(nextic->op) {
+
+ case '+':
+ pic14_emitcode(";optimize a +","");
+ /* if unsigned or not an integral type */
+ if (AOP_TYPE(IC_LEFT(nextic)) == AOP_CRY) {
+ pic14_emitcode(";add a bit to something","");
+ } else {
+
+ pic14_emitcode("movf","%s,w",AOP(nextright)->aopu.aop_dir);
+
+ if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ) {
+ pic14_emitcode("addwf","%s,w",AOP(nextleft)->aopu.aop_dir);
+ pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(nextic)),0,FALSE,FALSE));
+ } else
+ pic14_emitcode("addwf","%s,f",AOP(nextleft)->aopu.aop_dir);
+
+ offset = 0;
+ while(--big) {
+
+ offset++;
+
+ if(--small) {
+ if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
+ pic14_emitcode("movf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
+ }
+
+ pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ emitSKPNC;
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(nextic))->aopu.aop_dir,
+ AOP(IC_RIGHT(nextic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE));
+
+ } else {
+ pic14_emitcode("rlf","known_zero,w");
+
+ /*
+ if right is signed
+ btfsc right,7
+ addlw ff
+ */
+ if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
+ pic14_emitcode("addwf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
+ } else {
+ pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
+ }
+ }
+ }
+ ret = 1;
+ }
+ }
+ ret = 1;
+
release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(nextright,NULL,ic,TRUE);
+ freeAsmop(nextleft,NULL,ic,TRUE);
+ if(ret)
+ nextic->generated = 1;
+
+ return ret;
+#else
+ return 0;
+#endif
}
-
/*-----------------------------------------------------------------*/
-/* genModbits :- modulus of bits */
+/* genCast - gen code for casting */
/*-----------------------------------------------------------------*/
-static void
-genModbits (operand * left,
- operand * right,
- operand * result)
-{
+static void genCast (iCode *ic)
+{
+ operand *result = IC_RESULT(ic);
+ sym_link *restype = operandType(result);
+ sym_link *rtype = operandType(IC_RIGHT(ic));
+ operand *right = IC_RIGHT(ic);
+ int size, offset ;
+
+ FENTRY;
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if they are equivalent then do nothing */
+ if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
+ return ;
+
+ aopOp(right,ic,FALSE) ;
+ aopOp(result,ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* if the result is a bit */
+ if (AOP_TYPE(result) == AOP_CRY) {
+ assert(!"assigning to bit variables is not supported");
+ }
+
+ if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) {
+ int offset = 1;
+ size = AOP_SIZE(result);
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+
+ while (size--)
+ emitpcode(POC_CLRF, popGet(AOP(result),offset++));
+
+ goto release;
+ }
+
+ if (IS_PTR(restype))
+ {
+ operand *result = IC_RESULT(ic);
+ //operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ int tag = 0xff;
+
+ /* copy common part */
+ int max, size = AOP_SIZE(result);
+ if (size > AOP_SIZE(right)) size = AOP_SIZE(right);
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* warn if we discard generic opinter tag */
+ if (!IS_GENPTR(restype) && IS_GENPTR(rtype) && (AOP_SIZE(result) < AOP_SIZE(right)))
+ {
+ //fprintf (stderr, "%s:%u: discarding generic pointer type tag\n", __FUNCTION__, __LINE__);
+ } // if
- char *l;
+ max = size;
+ while (size--)
+ {
+ mov2w_op (right, size);
+ movwf (AOP(result), size);
+ } // while
+
+ /* upcast into generic pointer type? */
+ if (IS_GENPTR(restype)
+ && (size < AOP_SIZE(result))
+ && (!IS_GENPTR(rtype) || AOP_SIZE(right) < GPTRSIZE))
+ {
+ //fprintf (stderr, "%s:%u: must determine pointer type\n", __FUNCTION__, __LINE__);
+ if (IS_PTR(rtype))
+ {
+ switch (DCL_TYPE(rtype))
+ {
+ case POINTER: /* __data */
+ case FPOINTER: /* __data */
+ assert (AOP_SIZE(right) == 2);
+ tag = GPTRTAG_DATA;
+ break;
+
+ case CPOINTER: /* __code */
+ assert (AOP_SIZE(right) == 2);
+ tag = GPTRTAG_CODE;
+ break;
+
+ case GPOINTER: /* unknown destination, __data or __code */
+ /* assume __data space (address of immediate) */
+ assert (AOP_TYPE(right) == AOP_PCODE && AOP(right)->aopu.pcop->type == PO_IMMEDIATE);
+ if (AOP(right)->code)
+ tag = GPTRTAG_CODE;
+ else
+ tag = GPTRTAG_DATA;
+ break;
+
+ default:
+ assert (!"unhandled pointer type");
+ } // switch
+ } else {
+ /* convert other values into pointers to __data space */
+ tag = GPTRTAG_DATA;
+ }
- /* the result must be bit */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
+ assert (AOP_SIZE(result) == 3);
+ if (tag == 0) {
+ emitpcode(POC_CLRF, popGet(AOP(result), 2));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(tag));
+ movwf(AOP(result), 2);
+ }
+ } else {
+ addSign(result, max, 0);
+ } // if
+ goto release;
+ }
+
+ /* if they are the same size : or less */
+ if (AOP_SIZE(result) <= AOP_SIZE(right)) {
+
+ /* if they are in the same place */
+ if (pic14_sameRegs(AOP(right),AOP(result)))
+ goto release;
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (IS_PTR_CONST(rtype))
+ DEBUGpic14_emitcode ("; ***","%d - right is const pointer",__LINE__);
+ if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
+ DEBUGpic14_emitcode ("; ***","%d - result is const pointer",__LINE__);
+
+ if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+ emitpcode(POC_MOVLW, popGetAddr(AOP(right),0,0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW, popGetAddr(AOP(right),1,0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),1));
+ if(AOP_SIZE(result) <2)
+ fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
+
+ } else {
+
+ /* if they in different places then copy */
+ size = AOP_SIZE(result);
+ offset = 0 ;
+ while (size--) {
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+ //aopPut(AOP(result),
+ // aopGet(AOP(right),offset,FALSE,FALSE),
+ // offset);
+
+ offset++;
+ }
+ }
+ goto release;
+ }
+
+ /* so we now know that the size of destination is greater
+ than the size of the source.
+ Now, if the next iCode is an operator then we might be
+ able to optimize the operation without performing a cast.
+ */
+ if(0 && genMixedOperation(ic)) {
+ /* XXX: cannot optimize: must copy regs! */
+ goto release;
+ }
+
+ /* we move to result for the size of source */
+ size = AOP_SIZE(right);
+ offset = 0 ;
+ while (size--) {
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ offset++;
+ }
- MOVA (l);
+ addSign (result, AOP_SIZE(right), !SPEC_USIGN(rtype));
- emitcode ("div", "ab");
- emitcode ("mov", "a,b");
- emitcode ("rrc", "a");
- aopPut (AOP (result), "c", 0);
+release:
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
}
/*-----------------------------------------------------------------*/
-/* genModOneByte : 8 bit modulus */
+/* genDjnz - generate decrement & jump if not zero instrucion */
/*-----------------------------------------------------------------*/
-static void
-genModOneByte (operand * left,
- operand * right,
- operand * result)
-{
- sym_link *opetype = operandType (result);
- char *l;
- symbol *lbl;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* signed or unsigned */
- if (SPEC_USIGN (opetype))
- {
- /* unsigned is easy */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("div", "ab");
- aopPut (AOP (result), "b", 0);
- return;
- }
-
- /* signed is a little bit more difficult */
-
- /* save the signs of the operands */
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
-
- emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- emitcode ("push", "acc"); /* save it on the stack */
-
- /* now sign adjust for both left & right */
- l = aopGet (AOP (right), 0, FALSE, FALSE);
- MOVA (l);
-
- lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d_DS_", (lbl->key + 100));
- emitcode ("cpl", "a");
- emitcode ("inc", "a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- emitcode ("mov", "b,a");
-
- /* sign adjust left side */
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
-
- lbl = newiTempLabel (NULL);
- emitcode ("jnb", "acc.7,%05d_DS_", (lbl->key + 100));
- emitcode ("cpl", "a");
- emitcode ("inc", "a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
-
- /* now the multiplication */
- emitcode ("div", "ab");
- /* we are interested in the lower order
- only */
- lbl = newiTempLabel (NULL);
- emitcode ("pop", "acc");
- /* if there was an over flow we don't
- adjust the sign of the result */
- emitcode ("jb", "ov,%05d_DS_", (lbl->key + 100));
- emitcode ("jnb", "acc.7,%05d_DS_", (lbl->key + 100));
- CLRC;
- emitcode ("clr", "a");
- emitcode ("subb", "a,b");
- emitcode ("mov", "b,a");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
-
- /* now we are done */
- aopPut (AOP (result), "b", 0);
-
+static int genDjnz (iCode *ic, iCode *ifx)
+{
+ symbol *lbl, *lbl1;
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (!ifx)
+ return 0;
+
+ /* if the if condition has a false label
+ then we cannot save */
+ if (IC_FALSE(ifx))
+ return 0;
+
+ /* if the minus is not of the form
+ a = a - 1 */
+ if (!isOperandEqual(IC_RESULT(ic),IC_LEFT(ic)) ||
+ !IS_OP_LITERAL(IC_RIGHT(ic)))
+ return 0;
+
+ if (operandLitValue(IC_RIGHT(ic)) != 1)
+ return 0;
+
+ /* if the size of this greater than one then no
+ saving */
+ if (getSize(operandType(IC_RESULT(ic))) > 1)
+ return 0;
+
+ /* otherwise we can save BIG */
+ lbl = newiTempLabel(NULL);
+ lbl1= newiTempLabel(NULL);
+
+ aopOp(IC_RESULT(ic),ic,FALSE);
+
+ if (IS_AOP_PREG(IC_RESULT(ic))) {
+ pic14_emitcode("dec","%s",
+ aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("mov","a,%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("jnz","%05d_DS_",lbl->key+100);
+ } else {
+
+
+ emitpcode(POC_DECFSZ,popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+
+ pic14_emitcode("decfsz","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ pic14_emitcode ("goto","_%05d_DS_",IC_TRUE(ifx)->key+100 + labelOffset);
+
+ }
+ /* pic14_emitcode ("sjmp","%05d_DS_",lbl1->key+100); */
+ /* pic14_emitcode ("","%05d_DS_:",lbl->key+100); */
+ /* pic14_emitcode ("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100); */
+ /* pic14_emitcode ("","%05d_DS_:",lbl1->key+100); */
+
+
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ ifx->generated = 1;
+ return 1;
}
/*-----------------------------------------------------------------*/
-/* genMod - generates code for division */
+/* genReceive - generate code for a receive iCode */
/*-----------------------------------------------------------------*/
-static void
-genMod (iCode * ic)
-{
- operand *left = IC_LEFT (ic);
- operand *right = IC_RIGHT (ic);
- operand *result = IC_RESULT (ic);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* assign the amsops */
- aopOp (left, ic, FALSE);
- aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
-
- /* special cases first */
- /* both are bits */
- if (AOP_TYPE (left) == AOP_CRY &&
- AOP_TYPE (right) == AOP_CRY)
- {
- genModbits (left, right, result);
- goto release;
- }
-
- /* if both are of size == 1 */
- if (AOP_SIZE (left) == 1 &&
- AOP_SIZE (right) == 1)
- {
- genModOneByte (left, right, result);
- goto release;
- }
-
- /* should have been converted to function call */
- assert (1);
-
-release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
+static void genReceive (iCode *ic)
+{
+ FENTRY;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ 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 = fReturnSizePic - size;
+ while (size--) {
+ pic14_emitcode ("push","%s", (strcmp(fReturn[fReturnSizePic - offset - 1],"a") ?
+ fReturn[fReturnSizePic - offset - 1] : "acc"));
+ offset++;
+ }
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_RESULT(ic));
+ offset = 0;
+ while (size--) {
+ pic14_emitcode ("pop","acc");
+ aopPut (AOP(IC_RESULT(ic)),"a",offset++);
+ }
+
+ } else {
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+ GpsuedoStkPtr = ic->parmBytes; // address used arg on stack
+ assignResultValue(IC_RESULT(ic));
+ }
+
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
-/* genIfxJump :- will create a jump depending on the ifx */
+/* genDummyRead - generate code for dummy read of volatiles */
/*-----------------------------------------------------------------*/
static void
-genIfxJump (iCode * ic, char *jval)
+genDummyRead (iCode * ic)
{
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if true label then we jump if condition
- supplied is true */
- if (IC_TRUE (ic))
- {
-
- if (strcmp (jval, "a") == 0)
- emitSKPZ;
- else if (strcmp (jval, "c") == 0)
- emitSKPC;
- else
- emitcode ("btfsc", "(%s >> 3),(%s & 7)", jval, jval);
-
- emitcode (" goto", "_%05d_DS_", IC_TRUE (ic)->key + 100 + labelOffset);
-
- }
- else
- {
- /* false label is present */
- if (strcmp (jval, "a") == 0)
- emitSKPNZ;
- else if (strcmp (jval, "c") == 0)
- emitSKPNC;
- else
- emitcode ("btfss", "(%s >> 3),(%s & 7)", jval, jval);
-
- emitcode (" goto", "_%05d_DS_", IC_FALSE (ic)->key + 100 + labelOffset);
-
- }
-
-
- /* mark the icode as generated */
- ic->generated = 1;
+ FENTRY;
+ pic14_emitcode ("; genDummyRead","");
+ pic14_emitcode ("; not implemented","");
+
+ ic = ic;
}
/*-----------------------------------------------------------------*/
-/* genSkip */
+/* genpic14Code - generate code for pic14 based controllers */
/*-----------------------------------------------------------------*/
-static void
-genSkip (iCode * ifx, int status_bit)
-{
- if (!ifx)
- return;
-
- if (IC_TRUE (ifx))
- {
- switch (status_bit)
- {
- case 'z':
- emitSKPNZ;
- break;
-
- case 'c':
- emitSKPNC;
- break;
-
- case 'd':
- emitcode ("skpndc", "");
- break;
-
+/*
+* At this point, ralloc.c has gone through the iCode and attempted
+* to optimize in a way suitable for a PIC. Now we've got to generate
+* PIC instructions that correspond to the iCode.
+*
+* Once the instructions are generated, we'll pass through both the
+* peep hole optimizer and the pCode optimizer.
+*-----------------------------------------------------------------*/
+
+void genpic14Code (iCode *lic)
+{
+ iCode *ic;
+ int cln = 0;
+ const char *cline;
+
+ FENTRY;
+ lineHead = lineCurr = NULL;
+
+ pb = newpCodeChain(GcurMemmap,0,newpCodeCharP("; Starting pCode block"));
+ addpBlock(pb);
+
+ /* if debug information required */
+ if (options.debug && currFunc) {
+ if (currFunc) {
+ debugFile->writeFunction (currFunc, lic);
+ }
}
-
- emitcode ("goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
-
- }
- else
- {
-
- switch (status_bit)
- {
-
- case 'z':
- emitSKPZ;
- break;
-
- case 'c':
- emitSKPC;
- break;
-
- case 'd':
- emitcode ("skpdc", "");
- break;
+
+
+ for (ic = lic ; ic ; ic = ic->next ) {
+
+ //DEBUGpic14_emitcode(";ic","");
+ //fprintf (stderr, "in ic loop\n");
+ //pic14_emitcode ("", ";\t%s:%d: %s", ic->filename,
+ //ic->lineno, printCLine(ic->filename, ic->lineno));
+
+ if (!options.noCcodeInAsm && (cln != ic->lineno)) {
+ cln = ic->lineno;
+ //fprintf (stderr, "%s\n", printCLine (ic->filename, ic->lineno));
+ cline = printCLine (ic->filename, ic->lineno);
+ if (!cline || strlen (cline) == 0) cline = printCLine (ic->filename, ic->lineno);
+ addpCode2pBlock (pb, newpCodeCSource (ic->lineno, ic->filename, cline));
+ //emitpComment ("[C-SRC] %s:%d: %s", ic->filename, cln, cline);
+ }
+
+ if (options.iCodeInAsm) {
+ char *iLine = printILine(ic);
+ emitpComment ("[ICODE] %s:%d: %s", ic->filename, ic->lineno, printILine (ic));
+ dbuf_free(iLine);
+ }
+ /* if the result is marked as
+ spilt and rematerializable or code for
+ this has already been generated then
+ do nothing */
+ if (resultRemat(ic) || ic->generated )
+ continue ;
+
+ /* depending on the operation */
+ switch (ic->op) {
+ case '!' :
+ genNot(ic);
+ break;
+
+ case '~' :
+ genCpl(ic);
+ break;
+
+ case UNARYMINUS:
+ genUminus (ic);
+ break;
+
+ case IPUSH:
+ genIpush (ic);
+ break;
+
+ case IPOP:
+ /* IPOP happens only when trying to restore a
+ spilt live range, if there is an ifx statement
+ following this pop then the if statement might
+ be using some of the registers being popped which
+ would destory the contents of the register so
+ we need to check for this condition and handle it */
+ if (ic->next &&
+ ic->next->op == IFX &&
+ regsInCommon(IC_LEFT(ic),IC_COND(ic->next)))
+ genIfx (ic->next,ic);
+ else
+ genIpop (ic);
+ break;
+
+ case CALL:
+ genCall (ic);
+ break;
+
+ case PCALL:
+ genPcall (ic);
+ break;
+
+ case FUNCTION:
+ genFunction (ic);
+ break;
+
+ case ENDFUNCTION:
+ genEndFunction (ic);
+ break;
+
+ case RETURN:
+ genRet (ic);
+ break;
+
+ case LABEL:
+ genLabel (ic);
+ break;
+
+ case GOTO:
+ genGoto (ic);
+ break;
+
+ case '+' :
+ genPlus (ic) ;
+ break;
+
+ case '-' :
+ if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
+ genMinus (ic);
+ break;
+
+ case '*' :
+ genMult (ic);
+ break;
+
+ case '/' :
+ genDiv (ic) ;
+ break;
+
+ case '%' :
+ genMod (ic);
+ break;
+
+ case '>' :
+ genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case '<' :
+ genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case LE_OP:
+ case GE_OP:
+ case NE_OP:
+
+ /* note these two are xlated by algebraic equivalence
+ during parsing SDCC.y */
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "got '>=' or '<=' shouldn't have come here");
+ break;
+
+ case EQ_OP:
+ genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case AND_OP:
+ genAndOp (ic);
+ break;
+
+ case OR_OP:
+ genOrOp (ic);
+ break;
+
+ case '^' :
+ genXor (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case '|' :
+ genOr (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case BITWISEAND:
+ genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case INLINEASM:
+ genInline (ic);
+ break;
+
+ case RRC:
+ genRRC (ic);
+ break;
+
+ case RLC:
+ genRLC (ic);
+ break;
+
+ case GETHBIT:
+ genGetHbit (ic);
+ break;
+
+ case LEFT_OP:
+ genLeftShift (ic);
+ break;
+
+ case RIGHT_OP:
+ genRightShift (ic);
+ break;
+
+ case GET_VALUE_AT_ADDRESS:
+ genPointerGet(ic);
+ break;
+
+ case '=' :
+ if (POINTER_SET(ic))
+ genPointerSet(ic);
+ else
+ genAssign(ic);
+ break;
+
+ case IFX:
+ genIfx (ic,NULL);
+ break;
+
+ case ADDRESS_OF:
+ genAddrOf (ic);
+ break;
+
+ case JUMPTABLE:
+ genJumpTab (ic);
+ break;
+
+ case CAST:
+ genCast (ic);
+ break;
+
+ case RECEIVE:
+ genReceive(ic);
+ break;
+
+ case SEND:
+ addSet(&_G.sendSet,ic);
+ break;
+
+ case DUMMY_READ_VOLATILE:
+ genDummyRead (ic);
+ break;
+
+ default :
+ fprintf(stderr, "UNHANDLED iCode: "); piCode(ic, stderr);
+ ic = ic;
+ break;
+ }
}
- emitcode ("goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
-
- }
+
+ /* now we are ready to call the
+ peep hole optimizer */
+ if (!options.nopeep) {
+ peepHole (&lineHead);
+ }
+ /* now do the actual printing */
+ printLine (lineHead,codeOutBuf);
+
+#ifdef PCODE_DEBUG
+ DFPRINTF((stderr,"printing pBlock\n\n"));
+ printpBlock(stdout,pb);
+#endif
+
+ return;
}
-/*-----------------------------------------------------------------*/
-/* genSkipc */
-/*-----------------------------------------------------------------*/
-static void
-genSkipc (iCode * ifx, int condition)
+/* This is not safe, as a AOP_PCODE/PO_IMMEDIATE might be used both as literal
+ * (meaning: representing its own address) or not (referencing its contents).
+ * This can only be decided based on the operand's type. */
+int
+aop_isLitLike (asmop *aop)
{
- if (!ifx)
- return;
-
- if (condition)
- emitSKPNC;
- else
- emitSKPC;
-
- if (IC_TRUE (ifx))
- emitcode ("goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
- else
- emitcode ("goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
-
+ assert (aop);
+ if (aop->type == AOP_LIT) return 1;
+if (aop->type == AOP_IMMD) return 1;
+ if ((aop->type == AOP_PCODE) &&
+ ((aop->aopu.pcop->type == PO_LITERAL)))
+ {
+ /* this should be treated like a literal/immediate (use MOVLW/ADDLW/SUBLW
+ * instead of MOVFW/ADDFW/SUBFW, use popGetAddr instead of popGet) */
+ return 1;
+ }
+ return 0;
}
-/*-----------------------------------------------------------------*/
-/* genSkipz */
-/*-----------------------------------------------------------------*/
-static void
-genSkipz (iCode * ifx, int condition)
-{
- if (!ifx)
- return;
-
- if (condition)
- emitSKPNZ;
- else
- emitSKPZ;
-
- if (IC_TRUE (ifx))
- emitcode ("goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
- else
- emitcode ("goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
-
-}
-/*-----------------------------------------------------------------*/
-/* genCmp :- greater or less than comparison */
-/*-----------------------------------------------------------------*/
-static void
-genCmp (operand * left, operand * right,
- operand * result, iCode * ifx, int sign)
-{
- int size, offset = 0;
- unsigned long lit = 0L, i = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if left & right are bit variables */
- if (AOP_TYPE (left) == AOP_CRY &&
- AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- emitcode ("anl", "c,/%s", AOP (left)->aopu.aop_dir);
- }
- else
- {
- /* subtract right from left if at the
- end the carry flag is set then we know that
- left is greater than right */
- size = max (AOP_SIZE (left), AOP_SIZE (right));
-
- /* if unsigned char cmp with lit, do cjne left,#right,zz */
- if ((size == 1) && !sign &&
- (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR))
- {
- symbol *lbl = newiTempLabel (NULL);
- emitcode ("cjne", "%s,%s,%05d_DS_",
- aopGet (AOP (left), offset, FALSE, FALSE),
- aopGet (AOP (right), offset, FALSE, FALSE),
- lbl->key + 100);
- emitcode ("", "%05d_DS_:", lbl->key + 100);
- }
- else
- {
-
- if (AOP_TYPE (right) == AOP_LIT)
- {
-
- DEBUGemitcode (";right lit", "%d", sign);
-
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
- //default:
- while (size--)
- {
- i = (lit >> (size * 8)) & 0xff;
- if (i == 0)
- {
- emitcode ("movf", "%s,w", aopGet (AOP (left), size, FALSE, FALSE));
- genSkipz (ifx, IC_TRUE (ifx) == NULL);
- }
- else
- {
- emitcode ("movlw", "0x%x", i);
- emitcode ("subwf", "%s,w", aopGet (AOP (left), size, FALSE, FALSE));
- genSkipc (ifx, IC_TRUE (ifx) == NULL);
- }
-
- }
- ifx->generated = 1;
- return;
- }
- if (AOP_TYPE (left) == AOP_LIT)
- {
-
- DEBUGemitcode (";left lit", "%d", sign);
-
- lit = (unsigned long) (floatFromVal (AOP (left)->aopu.aop_lit)) + 1;
-
- //default:
- while (size--)
- {
- i = (lit >> (size * 8)) & 0xff;
- if (i == 0)
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), size, FALSE, FALSE));
- genSkipz (ifx, IC_TRUE (ifx) != NULL);
- }
- else if (i == 1)
- {
- emitcode ("decf", "%s,w", aopGet (AOP (right), size, FALSE, FALSE));
- genSkipz (ifx, IC_TRUE (ifx) != NULL);
-
- }
- else
- {
- emitcode ("movlw", "0x%x", i);
- emitcode ("subwf", "%s,w", aopGet (AOP (right), size, FALSE, FALSE));
- genSkipc (ifx, IC_TRUE (ifx) != NULL);
- }
- }
- ifx->generated = 1;
- return;
- }
-
-
- // CLRC;
- DEBUGemitcode (";sign", "%d", sign);
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("subwf", "%s,w", aopGet (AOP (left), offset++, FALSE, FALSE));
- size--;
- while (size--)
- {
-
- /*if (AOP_TYPE(right) == AOP_LIT){
- unsigned long lit = (unsigned long)
- floatFromVal(AOP(right)->aopu.aop_lit);
- emitcode("subb","a,#0x%02x",
- 0x80 ^ (unsigned int)((lit >> (offset*8)) & 0x0FFL));
- } else {
- emitcode("mov","b,%s",aopGet(AOP(right),offset++,FALSE,FALSE));
- emitcode("xrl","b,#0x80");
- emitcode("subb","a,b");
- }
- } else
- emitcode("subb","a,%s",aopGet(AOP(right),offset++,FALSE,FALSE));
- */
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitSKPC;
- emitcode ("incfsz", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("subwf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- offset++;
- }
- }
- }
-
- //release:
- if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
- {
- outBitC (result);
- }
- else
- {
- /* if the result is used in the next
- ifx conditional branch then generate
- code a little differently */
- if (ifx)
- genIfxJump (ifx, "c");
- else
- outBitC (result);
- /* leave the result in acc */
- }
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genCmpGt :- greater than comparison */
-/*-----------------------------------------------------------------*/
-static void
-genCmpGt (iCode * ic, iCode * ifx)
-{
- operand *left, *right, *result;
- sym_link *letype, *retype;
- int sign;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- left = IC_LEFT (ic);
- right = IC_RIGHT (ic);
- result = IC_RESULT (ic);
-
- letype = getSpec (operandType (left));
- retype = getSpec (operandType (right));
- sign = !(SPEC_USIGN (letype) | SPEC_USIGN (retype));
- /* assign the amsops */
- aopOp (left, ic, FALSE);
- aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
-
- genCmp (right, left, result, ifx, sign);
-
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genCmpLt - less than comparisons */
-/*-----------------------------------------------------------------*/
-static void
-genCmpLt (iCode * ic, iCode * ifx)
-{
- operand *left, *right, *result;
- sym_link *letype, *retype;
- int sign;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- left = IC_LEFT (ic);
- right = IC_RIGHT (ic);
- result = IC_RESULT (ic);
-
- letype = getSpec (operandType (left));
- retype = getSpec (operandType (right));
- sign = !(SPEC_USIGN (letype) | SPEC_USIGN (retype));
-
- /* assign the amsops */
- aopOp (left, ic, FALSE);
- aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
-
- genCmp (left, right, result, ifx, sign);
-
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* gencjneshort - compare and jump if not equal */
-/*-----------------------------------------------------------------*/
-static void
-gencjneshort (operand * left, operand * right, symbol * lbl)
-{
- int size = max (AOP_SIZE (left), AOP_SIZE (right));
- int offset = 0;
- unsigned long lit = 0L;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if the left side is a literal or
- if the right is in a pointer register and left
- is not */
- if ((AOP_TYPE (left) == AOP_LIT) ||
- (IS_AOP_PREG (right) && !IS_AOP_PREG (left)))
- {
- operand *t = right;
- right = left;
- left = t;
- }
- if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
-
- /* if the right side is a literal then anything goes */
- if (AOP_TYPE (right) == AOP_LIT &&
- AOP_TYPE (left) != AOP_DIR)
- {
- while (size--)
- {
- if (lit & 0xff)
- {
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("xorlw", "0x%x", lit & 0xff);
- }
- else
- emitcode ("movf", "%s,f", aopGet (AOP (left), offset, FALSE, FALSE));
-
- emitSKPNZ;
- emitcode ("goto", "_%05d_DS_", lbl->key + 100 + labelOffset);
- offset++;
- lit >>= 8;
- }
- }
-
- /* if the right side is in a register or in direct space or
- if the left is a pointer register & right is not */
- else if (AOP_TYPE (right) == AOP_REG ||
- AOP_TYPE (right) == AOP_DIR ||
- (AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) ||
- (IS_AOP_PREG (left) && !IS_AOP_PREG (right)))
- {
- while (size--)
- {
- if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) &&
- ((lit & 0xff) != 0))
- {
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("xorlw", "0x%x", lit & 0xff);
- lit >>= 8;
- }
- else
- emitcode ("movf", "%s,f", aopGet (AOP (left), offset, FALSE, FALSE));
-
- emitSKPZ;
- emitcode ("goto", "_%05d_DS_", lbl->key + 100 + labelOffset);
- offset++;
-/*
- MOVA(aopGet(AOP(left),offset,FALSE,FALSE));
- if((AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) &&
- ((unsigned int)((lit >> (offset*8)) & 0x0FFL) == 0))
- emitcode("jnz","%05d_DS_",lbl->key+100);
- else
- emitcode("cjne","a,%s,%05d_DS_",
- aopGet(AOP(right),offset,FALSE,TRUE),
- lbl->key+100);
- offset++;
- */
- }
- }
- else
- {
- /* right is a pointer reg need both a & b */
- while (size--)
- {
- char *l = aopGet (AOP (left), offset, FALSE, FALSE);
- if (strcmp (l, "b"))
- emitcode ("mov", "b,%s", l);
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("cjne", "a,b,%05d_DS_", lbl->key + 100);
- offset++;
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* gencjne - compare and jump if not equal */
-/*-----------------------------------------------------------------*/
-static void
-gencjne (operand * left, operand * right, symbol * lbl)
-{
- symbol *tlbl = newiTempLabel (NULL);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- gencjneshort (left, right, lbl);
-
- emitcode ("mov", "a,%s", one);
- emitcode ("sjmp", "%05d_DS_", tlbl->key + 100);
- emitcode ("", "%05d_DS_:", lbl->key + 100);
- emitcode ("clr", "a");
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
-}
-
-
-/*-----------------------------------------------------------------*/
-/* genCmpEq - generates code for equal to */
-/*-----------------------------------------------------------------*/
-static void
-genCmpEq (iCode * ic, iCode * ifx)
-{
- operand *left, *right, *result;
- unsigned long lit = 0L;
- int size, offset = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (ifx)
- DEBUGemitcode ("; ifx is non-null", "");
- else
- DEBUGemitcode ("; ifx is null", "");
-
- aopOp ((left = IC_LEFT (ic)), ic, FALSE);
- aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
- aopOp ((result = IC_RESULT (ic)), ic, TRUE);
-
- size = max (AOP_SIZE (left), AOP_SIZE (right));
-
- /* if literal, literal on the right or
- if the right is in a pointer register and left
- is not */
- if ((AOP_TYPE (IC_LEFT (ic)) == AOP_LIT) ||
- (IS_AOP_PREG (right) && !IS_AOP_PREG (left)))
- {
- operand *t = IC_RIGHT (ic);
- IC_RIGHT (ic) = IC_LEFT (ic);
- IC_LEFT (ic) = t;
- }
-
- if (ifx && !AOP_SIZE (result))
- {
- symbol *tlbl;
- /* if they are both bit variables */
- if (AOP_TYPE (left) == AOP_CRY &&
- ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT)))
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- if (lit == 0L)
- {
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("cpl", "c");
- }
- else if (lit == 1L)
- {
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- }
- else
- {
- emitcode ("clr", "c");
- }
- /* AOP_TYPE(right) == AOP_CRY */
- }
- else
- {
- symbol *lbl = newiTempLabel (NULL);
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("jb", "%s,%05d_DS_", AOP (right)->aopu.aop_dir, (lbl->key + 100));
- emitcode ("cpl", "c");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- }
- /* if true label then we jump if condition
- supplied is true */
- tlbl = newiTempLabel (NULL);
- if (IC_TRUE (ifx))
- {
- emitcode ("jnc", "%05d_DS_", tlbl->key + 100);
- emitcode ("ljmp", "%05d_DS_", IC_TRUE (ifx)->key + 100);
- }
- else
- {
- emitcode ("jc", "%05d_DS_", tlbl->key + 100);
- emitcode ("ljmp", "%05d_DS_", IC_FALSE (ifx)->key + 100);
- }
- emitcode ("", "%05d_DS_:", tlbl->key + 100 + labelOffset);
- }
- else
- {
-
- /* They're not both bit variables. Is the right a literal? */
- if (AOP_TYPE (right) == AOP_LIT)
- {
-
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
- while (size--)
- {
-
- if (size >= 1)
- {
- int l = lit & 0xff;
- int h = (lit >> 8) & 0xff;
- int optimized = 0;
-
- /* Check special cases for integers */
- switch (lit & 0xffff)
- {
- case 0x0000:
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- genSkip (ifx, 'z');
- optimized++;
- break;
- case 0x0001:
- emitcode ("decf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- genSkip (ifx, 'z');
- optimized++;
- break;
- case 0x0100:
- emitcode ("decf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- genSkip (ifx, 'z');
- optimized++;
- break;
- case 0x00ff:
- emitcode ("incf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- genSkip (ifx, 'z');
- optimized++;
- break;
- case 0xff00:
- emitcode ("incf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- genSkip (ifx, 'z');
- optimized++;
- break;
- default:
- if (h == 0)
- {
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("xorlw", "0x%x", l);
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- optimized++;
- genSkip (ifx, 'z');
- }
- else if (l == 0)
- {
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- emitcode ("xorlw", "0x%x", h);
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- optimized++;
- genSkip (ifx, 'z');
- }
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("xorlw", "0x%x", l);
- emitcode ("movlw", "0x%x", h);
- emitSKPZ;
- emitcode ("xorwf", "%s,w", aopGet (AOP (left), offset + 1, FALSE, FALSE));
- optimized++;
- genSkip (ifx, 'z');
- }
-
- }
- if (optimized)
- {
- size--;
- offset += 2;
- lit >>= 16;
-
- continue;
- }
-
- }
-
- switch (lit & 0xff)
- {
- case 1:
- if (IC_TRUE (ifx))
- {
- emitcode ("decf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitSKPNZ;
- emitcode ("goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
- }
- else
- {
- emitcode ("decfsz", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
- }
- break;
- case 0xff:
- if (IC_TRUE (ifx))
- {
- emitcode ("incf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitSKPNZ;
- emitcode ("goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
- }
- else
- {
- emitcode ("incfsz", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
- }
- break;
- default:
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- if (lit)
- emitcode ("xorlw", "0x%x", lit & 0xff);
- genSkip (ifx, 'z');
- }
-
-
- // emitcode("goto","_%05d_DS_",tlbl->key+100+labelOffset);
- //emitcode("","_%05d_DS_:",tlbl->key+100+labelOffset);
- offset++;
- lit >>= 8;
- }
-
- }
- else if (AOP_TYPE (right) == AOP_CRY)
- {
- /* we know the left is not a bit, but that the right is */
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- if (IC_TRUE (ifx))
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- else
- emitcode ("btfss", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
-
- emitcode ("xorlw", "1");
-
- /* if the two are equal, then W will be 0 and the Z bit is set
- * we could test Z now, or go ahead and check the high order bytes if
- * the variable we're comparing is larger than a byte. */
-
- while (--size)
- emitcode ("iorwf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
-
- if (IC_TRUE (ifx))
- {
- emitSKPNZ;
- emitcode (" goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
- }
- else
- {
- emitSKPZ;
- emitcode (" goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
- }
-
- }
- else
- {
- /* They're both variables that are larger than bits */
- int s = size;
-
- tlbl = newiTempLabel (NULL);
-
- while (size--)
- {
-
- emitcode ("movf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("xorwf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
-
- if (IC_TRUE (ifx))
- {
- if (size)
- {
- emitSKPZ;
- emitcode (" goto", "_%05d_DS_", tlbl->key + 100 + labelOffset);
- }
- else
- {
- emitSKPNZ;
- emitcode (" goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
- }
- }
- else
- {
- emitSKPZ;
- emitcode (" goto", "_%05d_DS_", IC_FALSE (ifx)->key + 100 + labelOffset);
- }
- offset++;
- }
- if (s > 1 && IC_TRUE (ifx))
- emitcode ("", "_%05d_DS_:", tlbl->key + 100 + labelOffset);
- }
- }
- /* mark the icode as generated */
- ifx->generated = 1;
- goto release;
- }
-
- /* if they are both bit variables */
- if (AOP_TYPE (left) == AOP_CRY &&
- ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT)))
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- if (lit == 0L)
- {
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("cpl", "c");
- }
- else if (lit == 1L)
- {
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- }
- else
- {
- emitcode ("clr", "c");
- }
- /* AOP_TYPE(right) == AOP_CRY */
- }
- else
- {
- symbol *lbl = newiTempLabel (NULL);
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("jb", "%s,%05d_DS_", AOP (right)->aopu.aop_dir, (lbl->key + 100));
- emitcode ("cpl", "c");
- emitcode ("", "%05d_DS_:", (lbl->key + 100));
- }
- /* c = 1 if egal */
- if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
- {
- outBitC (result);
- goto release;
- }
- if (ifx)
- {
- genIfxJump (ifx, "c");
- goto release;
- }
- /* if the result is used in an arithmetic operation
- then put the result in place */
- outBitC (result);
- }
- else
- {
- gencjne (left, right, newiTempLabel (NULL));
- if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
- {
- aopPut (AOP (result), "a", 0);
- goto release;
- }
- if (ifx)
- {
- genIfxJump (ifx, "a");
- goto release;
- }
- /* if the result is used in an arithmetic operation
- then put the result in place */
- if (AOP_TYPE (result) != AOP_CRY)
- outAcc (result);
- /* leave the result in acc */
- }
-
-release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* ifxForOp - returns the icode containing the ifx for operand */
-/*-----------------------------------------------------------------*/
-static iCode *
-ifxForOp (operand * op, iCode * ic)
-{
- /* if true symbol then needs to be assigned */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (IS_TRUE_SYMOP (op))
- return NULL;
-
- /* if this has register type condition and
- the next instruction is ifx with the same operand
- and live to of the operand is upto the ifx only then */
- if (ic->next &&
- ic->next->op == IFX &&
- IC_COND (ic->next)->key == op->key &&
- OP_SYMBOL (op)->liveTo <= ic->next->seq)
- return ic->next;
-
- return NULL;
-}
-/*-----------------------------------------------------------------*/
-/* genAndOp - for && operation */
-/*-----------------------------------------------------------------*/
-static void
-genAndOp (iCode * ic)
-{
- operand *left, *right, *result;
- symbol *tlbl;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* note here that && operations that are in an
- if statement are taken away by backPatchLabels
- only those used in arthmetic operations remain */
- aopOp ((left = IC_LEFT (ic)), ic, FALSE);
- aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
- aopOp ((result = IC_RESULT (ic)), ic, FALSE);
-
- /* if both are bit variables */
- if (AOP_TYPE (left) == AOP_CRY &&
- AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
- outBitC (result);
- }
- else
- {
- tlbl = newiTempLabel (NULL);
- toBoolean (left);
- emitcode ("jz", "%05d_DS_", tlbl->key + 100);
- toBoolean (right);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- outBitAcc (result);
- }
-
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-
-/*-----------------------------------------------------------------*/
-/* genOrOp - for || operation */
-/*-----------------------------------------------------------------*/
-/*
- tsd pic port -
- modified this code, but it doesn't appear to ever get called
- */
-
-static void
-genOrOp (iCode * ic)
-{
- operand *left, *right, *result;
- symbol *tlbl;
-
- /* note here that || operations that are in an
- if statement are taken away by backPatchLabels
- only those used in arthmetic operations remain */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp ((left = IC_LEFT (ic)), ic, FALSE);
- aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
- aopOp ((result = IC_RESULT (ic)), ic, FALSE);
-
- /* if both are bit variables */
- if (AOP_TYPE (left) == AOP_CRY &&
- AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("clrc", "");
- emitcode ("btfss", "(%s >> 3), (%s & 7)",
- AOP (left)->aopu.aop_dir,
- AOP (left)->aopu.aop_dir);
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- emitcode ("setc", "");
-
- }
- else
- {
- tlbl = newiTempLabel (NULL);
- toBoolean (left);
- emitSKPZ;
- emitcode ("goto", "%05d_DS_", tlbl->key + 100 + labelOffset);
- toBoolean (right);
- emitcode ("", "%05d_DS_:", tlbl->key + 100 + labelOffset);
-
- outBitAcc (result);
- }
-
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* isLiteralBit - test if lit == 2^n */
-/*-----------------------------------------------------------------*/
-static int
-isLiteralBit (unsigned long lit)
-{
- unsigned long pw[32] =
- {1L, 2L, 4L, 8L, 16L, 32L, 64L, 128L,
- 0x100L, 0x200L, 0x400L, 0x800L,
- 0x1000L, 0x2000L, 0x4000L, 0x8000L,
- 0x10000L, 0x20000L, 0x40000L, 0x80000L,
- 0x100000L, 0x200000L, 0x400000L, 0x800000L,
- 0x1000000L, 0x2000000L, 0x4000000L, 0x8000000L,
- 0x10000000L, 0x20000000L, 0x40000000L, 0x80000000L};
- int idx;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- for (idx = 0; idx < 32; idx++)
- if (lit == pw[idx])
- return idx + 1;
- return 0;
-}
-
-/*-----------------------------------------------------------------*/
-/* continueIfTrue - */
-/*-----------------------------------------------------------------*/
-static void
-continueIfTrue (iCode * ic)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (IC_TRUE (ic))
- emitcode ("ljmp", "%05d_DS_", IC_TRUE (ic)->key + 100);
- ic->generated = 1;
-}
-
-/*-----------------------------------------------------------------*/
-/* jmpIfTrue - */
-/*-----------------------------------------------------------------*/
-static void
-jumpIfTrue (iCode * ic)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (!IC_TRUE (ic))
- emitcode ("ljmp", "%05d_DS_", IC_FALSE (ic)->key + 100);
- ic->generated = 1;
-}
-
-/*-----------------------------------------------------------------*/
-/* jmpTrueOrFalse - */
-/*-----------------------------------------------------------------*/
-static void
-jmpTrueOrFalse (iCode * ic, symbol * tlbl)
-{
- // ugly but optimized by peephole
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (IC_TRUE (ic))
- {
- symbol *nlbl = newiTempLabel (NULL);
- emitcode ("sjmp", "%05d_DS_", nlbl->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- emitcode ("ljmp", "%05d_DS_", IC_TRUE (ic)->key + 100);
- emitcode ("", "%05d_DS_:", nlbl->key + 100);
- }
- else
- {
- emitcode ("ljmp", "%05d_DS_", IC_FALSE (ic)->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- }
- ic->generated = 1;
-}
-
-/*-----------------------------------------------------------------*/
-/* genAnd - code for and */
-/*-----------------------------------------------------------------*/
-static void
-genAnd (iCode * ic, iCode * ifx)
-{
- operand *left, *right, *result;
- int size, offset = 0;
- unsigned long lit = 0L;
- int bytelit = 0;
- char buffer[10];
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp ((left = IC_LEFT (ic)), ic, FALSE);
- aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
- aopOp ((result = IC_RESULT (ic)), ic, TRUE);
-
-#ifdef DEBUG_TYPE
- emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
- AOP_TYPE (result),
- AOP_TYPE (left), AOP_TYPE (right));
- emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
- AOP_SIZE (result),
- AOP_SIZE (left), AOP_SIZE (right));
-#endif
-
- /* if left is a literal & right is not then exchange them */
- if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) ||
- AOP_NEEDSACC (left))
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- /* if result = right then exchange them */
- if (sameRegs (AOP (result), AOP (right)))
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- /* if right is bit then exchange them */
- if (AOP_TYPE (right) == AOP_CRY &&
- AOP_TYPE (left) != AOP_CRY)
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
- if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
-
- size = AOP_SIZE (result);
-
- // if(bit & yy)
- // result = bit & yy;
- if (AOP_TYPE (left) == AOP_CRY)
- {
- // c = bit & literal;
- if (AOP_TYPE (right) == AOP_LIT)
- {
- if (lit & 1)
- {
- if (size && sameRegs (AOP (result), AOP (left)))
- // no change
- goto release;
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- }
- else
- {
- // bit(result) = 0;
- if (size && (AOP_TYPE (result) == AOP_CRY))
- {
- emitcode ("clr", "%s", AOP (result)->aopu.aop_dir);
- goto release;
- }
- if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- {
- jumpIfTrue (ifx);
- goto release;
- }
- emitcode ("clr", "c");
- }
- }
- else
- {
- if (AOP_TYPE (right) == AOP_CRY)
- {
- // c = bit & bit;
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
- }
- else
- {
- // c = bit & val;
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
- // c = lsb
- emitcode ("rrc", "a");
- emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
- }
- }
- // bit = c
- // val = c
- if (size)
- outBitC (result);
- // if(bit & ...)
- else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c");
- goto release;
- }
-
- // if(val & 0xZZ) - size = 0, ifx != FALSE -
- // bit = val & 0xZZ - size = 1, ifx = FALSE -
- if ((AOP_TYPE (right) == AOP_LIT) &&
- (AOP_TYPE (result) == AOP_CRY) &&
- (AOP_TYPE (left) != AOP_CRY))
- {
- int posbit = isLiteralBit (lit);
- /* left & 2^n */
- if (posbit)
- {
- posbit--;
- MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE));
- // bit = left & 2^n
- if (size)
- emitcode ("mov", "c,acc.%d", posbit & 0x07);
- // if(left & 2^n)
- else
- {
- if (ifx)
- {
- sprintf (buffer, "acc.%d", posbit & 0x07);
- genIfxJump (ifx, buffer);
- }
- goto release;
- }
- }
- else
- {
- symbol *tlbl = newiTempLabel (NULL);
- int sizel = AOP_SIZE (left);
- if (size)
- emitcode ("setb", "c");
- while (sizel--)
- {
- if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
- {
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
- // byte == 2^n ?
- if ((posbit = isLiteralBit (bytelit)) != 0)
- emitcode ("jb", "acc.%d,%05d_DS_", (posbit - 1) & 0x07, tlbl->key + 100);
- else
- {
- if (bytelit != 0x0FFL)
- emitcode ("anl", "a,%s",
- aopGet (AOP (right), offset, FALSE, TRUE));
- emitcode ("jnz", "%05d_DS_", tlbl->key + 100);
- }
- }
- offset++;
- }
- // bit = left & literal
- if (size)
- {
- emitcode ("clr", "c");
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- }
- // if(left & literal)
- else
- {
- if (ifx)
- jmpTrueOrFalse (ifx, tlbl);
- goto release;
- }
- }
- outBitC (result);
- goto release;
- }
-
- /* if left is same as result */
- if (sameRegs (AOP (result), AOP (left)))
- {
- for (; size--; offset++, lit >>= 8)
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- switch (lit & 0xff)
- {
- case 0x00:
- /* and'ing with 0 has clears the result */
- emitcode ("clrf", "%s", aopGet (AOP (result), offset, FALSE, FALSE));
- break;
- case 0xff:
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- break;
-
- default:
- {
- int p = my_powof2 ((~lit) & 0xff);
- if (p >= 0)
- {
- /* only one bit is set in the literal, so use a bcf instruction */
- emitcode ("bcf", "%s,%d", aopGet (AOP (left), offset, FALSE, TRUE), p);
- }
- else
- {
- emitcode ("movlw", "0x%x", (lit & 0xff));
- emitcode ("andwf", "%s,f", aopGet (AOP (left), offset, FALSE, TRUE), p);
- }
- }
- }
- }
- else
- {
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("iorwf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("iorwf", "%s,f", aopGet (AOP (left), offset, FALSE, FALSE));
-
- }
- }
- }
-
- }
- else
- {
- // left & result in different registers
- if (AOP_TYPE (result) == AOP_CRY)
- {
- // result = bit
- // if(size), result in bit
- // if(!size && ifx), conditional oper: if(left & right)
- symbol *tlbl = newiTempLabel (NULL);
- int sizer = min (AOP_SIZE (left), AOP_SIZE (right));
- if (size)
- emitcode ("setb", "c");
- while (sizer--)
- {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("anl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("jnz", "%05d_DS_", tlbl->key + 100);
- offset++;
- }
- if (size)
- {
- CLRC;
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- outBitC (result);
- }
- else if (ifx)
- jmpTrueOrFalse (ifx, tlbl);
- }
- else
- {
- for (; (size--); offset++)
- {
- // normal case
- // result = left & right
- if (AOP_TYPE (right) == AOP_LIT)
- {
- int t = (lit >> (offset * 8)) & 0x0FFL;
- switch (t)
- {
- case 0x00:
- emitcode ("clrf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
- break;
- case 0xff:
- emitcode ("movf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
- break;
- default:
- emitcode ("movlw", "0x%x", t);
- emitcode ("andwf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
-
- }
- continue;
- }
-
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("andwf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("andwf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- }
- emitcode ("movwf", "%s", aopGet (AOP (result), offset, FALSE, FALSE));
- }
- }
- }
-
-release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genOr - code for or */
-/*-----------------------------------------------------------------*/
-static void
-genOr (iCode * ic, iCode * ifx)
-{
- operand *left, *right, *result;
- int size, offset = 0;
- unsigned long lit = 0L;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp ((left = IC_LEFT (ic)), ic, FALSE);
- aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
- aopOp ((result = IC_RESULT (ic)), ic, TRUE);
-
-
- /* if left is a literal & right is not then exchange them */
- if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) ||
- AOP_NEEDSACC (left))
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- /* if result = right then exchange them */
- if (sameRegs (AOP (result), AOP (right)))
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- /* if right is bit then exchange them */
- if (AOP_TYPE (right) == AOP_CRY &&
- AOP_TYPE (left) != AOP_CRY)
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
-
- size = AOP_SIZE (result);
-
- // if(bit | yy)
- // xx = bit | yy;
- if (AOP_TYPE (left) == AOP_CRY)
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- // c = bit & literal;
- if (lit)
- {
- // lit != 0 => result = 1
- if (AOP_TYPE (result) == AOP_CRY)
- {
- if (size)
- emitcode ("bsf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- else if (ifx)
- continueIfTrue (ifx);
- goto release;
- }
- emitcode (";XXXsetb", "c %s,%d", __FILE__, __LINE__);
- }
- else
- {
- // lit == 0 => result = left
- if (size && sameRegs (AOP (result), AOP (left)))
- goto release;
- emitcode (";XXX mov", "c,%s %s,%d", AOP (left)->aopu.aop_dir, __FILE__, __LINE__);
- }
- }
- else
- {
- if (AOP_TYPE (right) == AOP_CRY)
- {
- if (sameRegs (AOP (result), AOP (left)))
- {
- // c = bit | bit;
- emitcode ("bcf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- emitcode ("bsf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- }
- else
- {
-
- emitcode ("bcf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- emitcode ("btfss", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (left)->aopu.aop_dir,
- AOP (left)->aopu.aop_dir);
- emitcode ("bsf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- }
- }
- else
- {
- // c = bit | val;
- symbol *tlbl = newiTempLabel (NULL);
- emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
- if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
- emitcode (";XXX setb", "c");
- emitcode (";XXX jb", "%s,%05d_DS_",
- AOP (left)->aopu.aop_dir, tlbl->key + 100);
- toBoolean (right);
- emitcode (";XXX jnz", "%05d_DS_", tlbl->key + 100);
- if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- {
- jmpTrueOrFalse (ifx, tlbl);
- goto release;
- }
- else
- {
- CLRC;
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- }
- }
- }
- // bit = c
- // val = c
- if (size)
- outBitC (result);
- // if(bit | ...)
- else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c");
- goto release;
- }
-
- // if(val | 0xZZ) - size = 0, ifx != FALSE -
- // bit = val | 0xZZ - size = 1, ifx = FALSE -
- if ((AOP_TYPE (right) == AOP_LIT) &&
- (AOP_TYPE (result) == AOP_CRY) &&
- (AOP_TYPE (left) != AOP_CRY))
- {
- if (lit)
- {
- emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
- // result = 1
- if (size)
- emitcode (";XXX setb", "%s", AOP (result)->aopu.aop_dir);
- else
- continueIfTrue (ifx);
- goto release;
- }
- else
- {
- emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
- // lit = 0, result = boolean(left)
- if (size)
- emitcode (";XXX setb", "c");
- toBoolean (right);
- if (size)
- {
- symbol *tlbl = newiTempLabel (NULL);
- emitcode (";XXX jnz", "%05d_DS_", tlbl->key + 100);
- CLRC;
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- }
- else
- {
- genIfxJump (ifx, "a");
- goto release;
- }
- }
- outBitC (result);
- goto release;
- }
-
- /* if left is same as result */
- if (sameRegs (AOP (result), AOP (left)))
- {
- for (; size--; offset++, lit >>= 8)
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- if ((lit & 0xff) == 0)
- /* or'ing with 0 has no effect */
- continue;
- else
- {
- int p = my_powof2 (lit & 0xff);
- if (p >= 0)
- {
- /* only one bit is set in the literal, so use a bsf instruction */
- emitcode ("bsf", "%s,%d", aopGet (AOP (left), offset, FALSE, TRUE), p);
- }
- else
- {
- emitcode ("movlw", "0x%x", (lit & 0xff));
- emitcode ("iorwf", "%s,f", aopGet (AOP (left), offset, FALSE, TRUE), p);
- }
-
- }
- }
- else
- {
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("iorwf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("iorwf", "%s,f", aopGet (AOP (left), offset, FALSE, FALSE));
-
- }
- }
- }
- }
- else
- {
- // left & result in different registers
- if (AOP_TYPE (result) == AOP_CRY)
- {
- // result = bit
- // if(size), result in bit
- // if(!size && ifx), conditional oper: if(left | right)
- symbol *tlbl = newiTempLabel (NULL);
- int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
- emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
-
- if (size)
- emitcode (";XXX setb", "c");
- while (sizer--)
- {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode (";XXX orl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode (";XXX jnz", "%05d_DS_", tlbl->key + 100);
- offset++;
- }
- if (size)
- {
- CLRC;
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- outBitC (result);
- }
- else if (ifx)
- jmpTrueOrFalse (ifx, tlbl);
- }
- else
- for (; (size--); offset++)
- {
- // normal case
- // result = left & right
- if (AOP_TYPE (right) == AOP_LIT)
- {
- int t = (lit >> (offset * 8)) & 0x0FFL;
- switch (t)
- {
- case 0x00:
- emitcode ("movf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
- break;
- default:
- emitcode ("movlw", "0x%x", t);
- emitcode ("iorwf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
-
- }
- continue;
- }
-
- // faster than result <- left, anl result,right
- // and better if result is SFR
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("iorwf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("iorwf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- }
- emitcode ("movwf", "%s", aopGet (AOP (result), offset, FALSE, FALSE));
- }
- }
-
-release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genXor - code for xclusive or */
-/*-----------------------------------------------------------------*/
-static void
-genXor (iCode * ic, iCode * ifx)
-{
- operand *left, *right, *result;
- int size, offset = 0;
- unsigned long lit = 0L;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp ((left = IC_LEFT (ic)), ic, FALSE);
- aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
- aopOp ((result = IC_RESULT (ic)), ic, TRUE);
-
- /* if left is a literal & right is not ||
- if left needs acc & right does not */
- if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) ||
- (AOP_NEEDSACC (left) && !AOP_NEEDSACC (right)))
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- /* if result = right then exchange them */
- if (sameRegs (AOP (result), AOP (right)))
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
-
- /* if right is bit then exchange them */
- if (AOP_TYPE (right) == AOP_CRY &&
- AOP_TYPE (left) != AOP_CRY)
- {
- operand *tmp = right;
- right = left;
- left = tmp;
- }
- if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
-
- size = AOP_SIZE (result);
-
- // if(bit ^ yy)
- // xx = bit ^ yy;
- if (AOP_TYPE (left) == AOP_CRY)
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- // c = bit & literal;
- if (lit >> 1)
- {
- // lit>>1 != 0 => result = 1
- if (AOP_TYPE (result) == AOP_CRY)
- {
- if (size)
- emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
- else if (ifx)
- continueIfTrue (ifx);
- goto release;
- }
- emitcode ("setb", "c");
- }
- else
- {
- // lit == (0 or 1)
- if (lit == 0)
- {
- // lit == 0, result = left
- if (size && sameRegs (AOP (result), AOP (left)))
- goto release;
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- }
- else
- {
- // lit == 1, result = not(left)
- if (size && sameRegs (AOP (result), AOP (left)))
- {
- emitcode ("cpl", "%s", AOP (result)->aopu.aop_dir);
- goto release;
- }
- else
- {
- emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
- emitcode ("cpl", "c");
- }
- }
- }
-
- }
- else
- {
- // right != literal
- symbol *tlbl = newiTempLabel (NULL);
- if (AOP_TYPE (right) == AOP_CRY)
- {
- // c = bit ^ bit;
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- }
- else
- {
- int sizer = AOP_SIZE (right);
- // c = bit ^ val
- // if val>>1 != 0, result = 1
- emitcode ("setb", "c");
- while (sizer)
- {
- MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE));
- if (sizer == 1)
- // test the msb of the lsb
- emitcode ("anl", "a,#0xfe");
- emitcode ("jnz", "%05d_DS_", tlbl->key + 100);
- sizer--;
- }
- // val = (0,1)
- emitcode ("rrc", "a");
- }
- emitcode ("jnb", "%s,%05d_DS_", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
- emitcode ("cpl", "c");
- emitcode ("", "%05d_DS_:", (tlbl->key + 100));
- }
- // bit = c
- // val = c
- if (size)
- outBitC (result);
- // if(bit | ...)
- else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c");
- goto release;
- }
-
- if (sameRegs (AOP (result), AOP (left)))
- {
- /* if left is same as result */
- for (; size--; offset++)
- {
- if (AOP_TYPE (right) == AOP_LIT)
- {
- if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
- continue;
- else if (IS_AOP_PREG (left))
- {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset);
- }
- else
- emitcode ("xrl", "%s,%s",
- aopGet (AOP (left), offset, FALSE, TRUE),
- aopGet (AOP (right), offset, FALSE, FALSE));
- }
- else
- {
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- if (IS_AOP_PREG (left))
- {
- emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset);
- }
- else
- emitcode ("xrl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
- }
- }
- }
- }
- else
- {
- // left & result in different registers
- if (AOP_TYPE (result) == AOP_CRY)
- {
- // result = bit
- // if(size), result in bit
- // 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--)
- {
- if ((AOP_TYPE (right) == AOP_LIT) &&
- (((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
- {
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
- }
- else
- {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("xrl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
- }
- emitcode ("jnz", "%05d_DS_", tlbl->key + 100);
- offset++;
- }
- if (size)
- {
- CLRC;
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- outBitC (result);
- }
- else if (ifx)
- jmpTrueOrFalse (ifx, tlbl);
- }
- else
- for (; (size--); offset++)
- {
- // normal case
- // result = left & right
- if (AOP_TYPE (right) == AOP_LIT)
- {
- int t = (lit >> (offset * 8)) & 0x0FFL;
- switch (t)
- {
- case 0x00:
- emitcode ("movf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
- break;
- case 0xff:
- emitcode ("comf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
- break;
- default:
- emitcode ("movlw", "0x%x", t);
- emitcode ("xorwf", "%s,w",
- aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset, FALSE, FALSE));
-
- }
- continue;
- }
-
- // faster than result <- left, anl result,right
- // and better if result is SFR
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("xorwf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("xorwf", "%s,w", aopGet (AOP (left), offset, FALSE, FALSE));
- }
- if (AOP_TYPE (result) != AOP_ACC)
- emitcode ("movwf", "%s", aopGet (AOP (result), offset, FALSE, FALSE));
- }
- }
-
-release:
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genInline - write the inline code out */
-/*-----------------------------------------------------------------*/
-static void
-genInline (iCode * ic)
-{
- char buffer[MAX_INLINEASM];
- char *bp = buffer;
- char *bp1 = buffer;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- _G.inLine += (!options.asmpeep);
- strcpy (buffer, IC_INLINE (ic));
-
- /* emit each line as a code */
- while (*bp)
- {
- if (*bp == '\n')
- {
- *bp++ = '\0';
- emitcode (bp1, "");
- bp1 = bp;
- }
- else
- {
- if (*bp == ':')
- {
- bp++;
- *bp = '\0';
- bp++;
- emitcode (bp1, "");
- bp1 = bp;
- }
- else
- bp++;
- }
- }
- if (bp1 != bp)
- emitcode (bp1, "");
- /* emitcode("",buffer); */
- _G.inLine -= (!options.asmpeep);
-}
-
-/*-----------------------------------------------------------------*/
-/* genRRC - rotate right with carry */
-/*-----------------------------------------------------------------*/
-static void
-genRRC (iCode * ic)
-{
- operand *left, *result;
- int size, offset = 0;
- char *l;
-
- /* rotate right with carry */
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- /* move it to the result */
- size = AOP_SIZE (result);
- offset = size - 1;
- CLRC;
- while (size--)
- {
- l = aopGet (AOP (left), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("rrc", "a");
- if (AOP_SIZE (result) > 1)
- aopPut (AOP (result), "a", offset--);
- }
- /* now we need to put the carry into the
- highest order byte of the result */
- if (AOP_SIZE (result) > 1)
- {
- l = aopGet (AOP (result), AOP_SIZE (result) - 1, FALSE, FALSE);
- MOVA (l);
- }
- emitcode ("mov", "acc.7,c");
- aopPut (AOP (result), "a", AOP_SIZE (result) - 1);
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genRLC - generate code for rotate left with carry */
-/*-----------------------------------------------------------------*/
-static void
-genRLC (iCode * ic)
-{
- operand *left, *result;
- int size, offset = 0;
- char *l;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* rotate right with carry */
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- /* move it to the result */
- size = AOP_SIZE (result);
- offset = 0;
- if (size--)
- {
- l = aopGet (AOP (left), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("add", "a,acc");
- if (AOP_SIZE (result) > 1)
- aopPut (AOP (result), "a", offset++);
- while (size--)
- {
- l = aopGet (AOP (left), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("rlc", "a");
- if (AOP_SIZE (result) > 1)
- aopPut (AOP (result), "a", offset++);
- }
- }
- /* now we need to put the carry into the
- highest order byte of the result */
- if (AOP_SIZE (result) > 1)
- {
- l = aopGet (AOP (result), 0, FALSE, FALSE);
- MOVA (l);
- }
- emitcode ("mov", "acc.0,c");
- aopPut (AOP (result), "a", 0);
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genGetHbit - generates code get highest order bit */
-/*-----------------------------------------------------------------*/
-static void
-genGetHbit (iCode * ic)
-{
- operand *left, *result;
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* get the highest order byte into a */
- MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE));
- if (AOP_TYPE (result) == AOP_CRY)
- {
- emitcode ("rlc", "a");
- outBitC (result);
- }
- else
- {
- emitcode ("rl", "a");
- emitcode ("anl", "a,#0x01");
- outAcc (result);
- }
-
-
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* AccRol - rotate left accumulator by known count */
-/*-----------------------------------------------------------------*/
-static void
-AccRol (int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- shCount &= 0x0007; // shCount : 0..7
-
- switch (shCount)
- {
- case 0:
- break;
- case 1:
- emitcode ("rl", "a");
- break;
- case 2:
- emitcode ("rl", "a");
- emitcode ("rl", "a");
- break;
- case 3:
- emitcode ("swap", "a");
- emitcode ("rr", "a");
- break;
- case 4:
- emitcode ("swap", "a");
- break;
- case 5:
- emitcode ("swap", "a");
- emitcode ("rl", "a");
- break;
- case 6:
- emitcode ("rr", "a");
- emitcode ("rr", "a");
- break;
- case 7:
- emitcode ("rr", "a");
- break;
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* AccLsh - left shift accumulator by known count */
-/*-----------------------------------------------------------------*/
-static void
-AccLsh (int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (shCount != 0)
- {
- if (shCount == 1)
- emitcode ("add", "a,acc");
- else if (shCount == 2)
- {
- emitcode ("add", "a,acc");
- emitcode ("add", "a,acc");
- }
- else
- {
- /* rotate left accumulator */
- AccRol (shCount);
- /* and kill the lower order bits */
- emitcode ("anl", "a,#0x%02x", SLMask[shCount]);
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* AccRsh - right shift accumulator by known count */
-/*-----------------------------------------------------------------*/
-static void
-AccRsh (int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (shCount != 0)
- {
- if (shCount == 1)
- {
- CLRC;
- emitcode ("rrc", "a");
- }
- else
- {
- /* rotate right accumulator */
- AccRol (8 - shCount);
- /* and kill the higher order bits */
- emitcode ("anl", "a,#0x%02x", SRMask[shCount]);
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* AccSRsh - signed right shift accumulator by known count */
-/*-----------------------------------------------------------------*/
-static void
-AccSRsh (int shCount)
-{
- symbol *tlbl;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (shCount != 0)
- {
- if (shCount == 1)
- {
- emitcode ("mov", "c,acc.7");
- emitcode ("rrc", "a");
- }
- else if (shCount == 2)
- {
- emitcode ("mov", "c,acc.7");
- emitcode ("rrc", "a");
- emitcode ("mov", "c,acc.7");
- emitcode ("rrc", "a");
- }
- else
- {
- tlbl = newiTempLabel (NULL);
- /* rotate right accumulator */
- AccRol (8 - shCount);
- /* and kill the higher order bits */
- emitcode ("anl", "a,#0x%02x", SRMask[shCount]);
- emitcode ("jnb", "acc.%d,%05d_DS_", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
- (unsigned char) ~SRMask[shCount]);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftR1Left2Result - shift right one byte from left to result */
-/*-----------------------------------------------------------------*/
-static void
-shiftR1Left2Result (operand * left, int offl,
- operand * result, int offr,
- int shCount, int sign)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- /* shift right accumulator */
- if (sign)
- AccSRsh (shCount);
- else
- AccRsh (shCount);
- aopPut (AOP (result), "a", offr);
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftL1Left2Result - shift left one byte from left to result */
-/*-----------------------------------------------------------------*/
-static void
-shiftL1Left2Result (operand * left, int offl,
- operand * result, int offr, int shCount)
-{
- char *l;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- l = aopGet (AOP (left), offl, FALSE, FALSE);
- MOVA (l);
- /* shift left accumulator */
- AccLsh (shCount);
- aopPut (AOP (result), "a", offr);
-}
-
-/*-----------------------------------------------------------------*/
-/* movLeft2Result - move byte from left to result */
-/*-----------------------------------------------------------------*/
-static void
-movLeft2Result (operand * left, int offl,
- operand * result, int offr, int sign)
-{
- char *l;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (!sameRegs (AOP (left), AOP (result)) || (offl != offr))
- {
- l = aopGet (AOP (left), offl, FALSE, FALSE);
-
- if (*l == '@' && (IS_AOP_PREG (result)))
- {
- emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offr);
- }
- else
- {
- if (!sign)
- aopPut (AOP (result), l, offr);
- else
- {
- /* MSB sign in acc.7 ! */
- if (getDataSize (left) == offl + 1)
- {
- emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offr);
- }
- }
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* AccAXRrl1 - right rotate c->a:x->c by 1 */
-/*-----------------------------------------------------------------*/
-static void
-AccAXRrl1 (char *x)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- emitcode ("rrc", "a");
- emitcode ("xch", "a,%s", x);
- emitcode ("rrc", "a");
- emitcode ("xch", "a,%s", x);
-}
-
-/*-----------------------------------------------------------------*/
-/* AccAXLrl1 - left rotate c<-a:x<-c by 1 */
-/*-----------------------------------------------------------------*/
-static void
-AccAXLrl1 (char *x)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- emitcode ("xch", "a,%s", x);
- emitcode ("rlc", "a");
- emitcode ("xch", "a,%s", x);
- emitcode ("rlc", "a");
-}
-
-/*-----------------------------------------------------------------*/
-/* AccAXLsh1 - left shift a:x<-0 by 1 */
-/*-----------------------------------------------------------------*/
-static void
-AccAXLsh1 (char *x)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- emitcode ("xch", "a,%s", x);
- emitcode ("add", "a,acc");
- emitcode ("xch", "a,%s", x);
- emitcode ("rlc", "a");
-}
-
-/*-----------------------------------------------------------------*/
-/* AccAXLsh - left shift a:x by known count (0..7) */
-/*-----------------------------------------------------------------*/
-static void
-AccAXLsh (char *x, int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- switch (shCount)
- {
- case 0:
- break;
- case 1:
- AccAXLsh1 (x);
- break;
- case 2:
- AccAXLsh1 (x);
- AccAXLsh1 (x);
- break;
- case 3:
- case 4:
- case 5: // AAAAABBB:CCCCCDDD
-
- AccRol (shCount); // BBBAAAAA:CCCCCDDD
-
- emitcode ("anl", "a,#0x%02x",
- SLMask[shCount]); // BBB00000:CCCCCDDD
-
- emitcode ("xch", "a,%s", x); // CCCCCDDD:BBB00000
-
- AccRol (shCount); // DDDCCCCC:BBB00000
-
- emitcode ("xch", "a,%s", x); // BBB00000:DDDCCCCC
-
- emitcode ("xrl", "a,%s", x); // (BBB^DDD)CCCCC:DDDCCCCC
-
- emitcode ("xch", "a,%s", x); // DDDCCCCC:(BBB^DDD)CCCCC
-
- emitcode ("anl", "a,#0x%02x",
- SLMask[shCount]); // DDD00000:(BBB^DDD)CCCCC
-
- emitcode ("xch", "a,%s", x); // (BBB^DDD)CCCCC:DDD00000
-
- emitcode ("xrl", "a,%s", x); // BBBCCCCC:DDD00000
-
- break;
- case 6: // AAAAAABB:CCCCCCDD
-
- emitcode ("anl", "a,#0x%02x",
- SRMask[shCount]); // 000000BB:CCCCCCDD
-
- emitcode ("mov", "c,acc.0"); // c = B
-
- emitcode ("xch", "a,%s", x); // CCCCCCDD:000000BB
-
- AccAXRrl1 (x); // BCCCCCCD:D000000B
-
- AccAXRrl1 (x); // BBCCCCCC:DD000000
-
- break;
- case 7: // a:x <<= 7
-
- emitcode ("anl", "a,#0x%02x",
- SRMask[shCount]); // 0000000B:CCCCCCCD
-
- emitcode ("mov", "c,acc.0"); // c = B
-
- emitcode ("xch", "a,%s", x); // CCCCCCCD:0000000B
-
- AccAXRrl1 (x); // BCCCCCCC:D0000000
-
- break;
- default:
- break;
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* AccAXRsh - right shift a:x known count (0..7) */
-/*-----------------------------------------------------------------*/
-static void
-AccAXRsh (char *x, int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- switch (shCount)
- {
- case 0:
- break;
- case 1:
- CLRC;
- AccAXRrl1 (x); // 0->a:x
-
- break;
- case 2:
- CLRC;
- AccAXRrl1 (x); // 0->a:x
-
- CLRC;
- AccAXRrl1 (x); // 0->a:x
-
- break;
- case 3:
- case 4:
- case 5: // AAAAABBB:CCCCCDDD = a:x
-
- AccRol (8 - shCount); // BBBAAAAA:DDDCCCCC
-
- emitcode ("xch", "a,%s", x); // CCCCCDDD:BBBAAAAA
-
- AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
-
- emitcode ("anl", "a,#0x%02x",
- 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",
- SRMask[shCount]); // 000AAAAA:BBB(CCCCC^AAAAA)
-
- emitcode ("xch", "a,%s", x); // BBB(CCCCC^AAAAA):000AAAAA
-
- emitcode ("xrl", "a,%s", x); // BBBCCCCC:000AAAAA
-
- emitcode ("xch", "a,%s", x); // 000AAAAA:BBBCCCCC
-
- break;
- case 6: // AABBBBBB:CCDDDDDD
-
- emitcode ("mov", "c,acc.7");
- AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
-
- AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
-
- emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
-
- emitcode ("anl", "a,#0x%02x",
- SRMask[shCount]); // 000000AA:BBBBBBCC
-
- break;
- case 7: // ABBBBBBB:CDDDDDDD
-
- emitcode ("mov", "c,acc.7"); // c = A
-
- AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA
-
- emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC
-
- emitcode ("anl", "a,#0x%02x",
- SRMask[shCount]); // 0000000A:BBBBBBBC
-
- break;
- default:
- break;
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* AccAXRshS - right shift signed a:x known count (0..7) */
-/*-----------------------------------------------------------------*/
-static void
-AccAXRshS (char *x, int shCount)
-{
- symbol *tlbl;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- switch (shCount)
- {
- case 0:
- break;
- case 1:
- emitcode ("mov", "c,acc.7");
- AccAXRrl1 (x); // s->a:x
-
- break;
- case 2:
- emitcode ("mov", "c,acc.7");
- AccAXRrl1 (x); // s->a:x
-
- emitcode ("mov", "c,acc.7");
- AccAXRrl1 (x); // s->a:x
-
- break;
- case 3:
- case 4:
- case 5: // AAAAABBB:CCCCCDDD = a:x
-
- tlbl = newiTempLabel (NULL);
- AccRol (8 - shCount); // BBBAAAAA:CCCCCDDD
-
- emitcode ("xch", "a,%s", x); // CCCCCDDD:BBBAAAAA
-
- AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
-
- emitcode ("anl", "a,#0x%02x",
- 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",
- SRMask[shCount]); // 000AAAAA:BBB(CCCCC^AAAAA)
-
- emitcode ("xch", "a,%s", x); // BBB(CCCCC^AAAAA):000AAAAA
-
- emitcode ("xrl", "a,%s", x); // BBBCCCCC:000AAAAA
-
- emitcode ("xch", "a,%s", x); // 000SAAAA:BBBCCCCC
-
- emitcode ("jnb", "acc.%d,%05d_DS_", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
- (unsigned char) ~SRMask[shCount]); // 111AAAAA:BBBCCCCC
-
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- break; // SSSSAAAA:BBBCCCCC
-
- case 6: // AABBBBBB:CCDDDDDD
-
- tlbl = newiTempLabel (NULL);
- emitcode ("mov", "c,acc.7");
- AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
-
- AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
-
- emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
-
- emitcode ("anl", "a,#0x%02x",
- SRMask[shCount]); // 000000AA:BBBBBBCC
-
- emitcode ("jnb", "acc.%d,%05d_DS_", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
- (unsigned char) ~SRMask[shCount]); // 111111AA:BBBBBBCC
-
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- break;
- case 7: // ABBBBBBB:CDDDDDDD
-
- tlbl = newiTempLabel (NULL);
- emitcode ("mov", "c,acc.7"); // c = A
-
- AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA
-
- emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC
-
- emitcode ("anl", "a,#0x%02x",
- SRMask[shCount]); // 0000000A:BBBBBBBC
-
- emitcode ("jnb", "acc.%d,%05d_DS_", 7 - shCount, tlbl->key + 100);
- emitcode ("orl", "a,#0x%02x",
- (unsigned char) ~SRMask[shCount]); // 1111111A:BBBBBBBC
-
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- break;
- default:
- break;
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftL2Left2Result - shift left two bytes from left to result */
-/*-----------------------------------------------------------------*/
-static void
-shiftL2Left2Result (operand * left, int offl,
- operand * result, int offr, int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (sameRegs (AOP (result), AOP (left)) &&
- ((offl + MSB16) == offr))
- {
- /* don't crash result[offr] */
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- emitcode ("xch", "a,%s", aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
- }
- else
- {
- movLeft2Result (left, offl, result, offr, 0);
- MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
- }
- /* ax << shCount (x = lsb(result)) */
- AccAXLsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
- aopPut (AOP (result), "a", offr + MSB16);
-}
-
-
-/*-----------------------------------------------------------------*/
-/* shiftR2Left2Result - shift right two bytes from left to result */
-/*-----------------------------------------------------------------*/
-static void
-shiftR2Left2Result (operand * left, int offl,
- operand * result, int offr,
- int shCount, int sign)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (sameRegs (AOP (result), AOP (left)) &&
- ((offl + MSB16) == offr))
- {
- /* don't crash result[offr] */
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- emitcode ("xch", "a,%s", aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
- }
- else
- {
- movLeft2Result (left, offl, result, offr, 0);
- MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
- }
- /* a:x >> shCount (x = lsb(result)) */
- if (sign)
- AccAXRshS (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
- else
- AccAXRsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
- if (getDataSize (result) > 1)
- aopPut (AOP (result), "a", offr + MSB16);
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftLLeftOrResult - shift left one byte from left, or to result */
-/*-----------------------------------------------------------------*/
-static void
-shiftLLeftOrResult (operand * left, int offl,
- operand * result, int offr, int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- /* shift left accumulator */
- AccLsh (shCount);
- /* or with result */
- emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE));
- /* back to result */
- aopPut (AOP (result), "a", offr);
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftRLeftOrResult - shift right one byte from left,or to result */
-/*-----------------------------------------------------------------*/
-static void
-shiftRLeftOrResult (operand * left, int offl,
- operand * result, int offr, int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- /* shift right accumulator */
- AccRsh (shCount);
- /* or with result */
- emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE));
- /* back to result */
- aopPut (AOP (result), "a", offr);
-}
-
-/*-----------------------------------------------------------------*/
-/* genlshOne - left shift a one byte quantity by known count */
-/*-----------------------------------------------------------------*/
-static void
-genlshOne (operand * result, operand * left, int shCount)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- shiftL1Left2Result (left, LSB, result, LSB, shCount);
-}
-
-/*-----------------------------------------------------------------*/
-/* genlshTwo - left shift two bytes by known amount != 0 */
-/*-----------------------------------------------------------------*/
-static void
-genlshTwo (operand * result, operand * left, int shCount)
-{
- int size;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- size = getDataSize (result);
-
- /* if shCount >= 8 */
- if (shCount >= 8)
- {
- shCount -= 8;
-
- if (size > 1)
- {
- if (shCount)
- shiftL1Left2Result (left, LSB, result, MSB16, shCount);
- else
- movLeft2Result (left, LSB, result, MSB16, 0);
- }
- aopPut (AOP (result), zero, LSB);
- }
-
- /* 1 <= shCount <= 7 */
- else
- {
- if (size == 1)
- shiftL1Left2Result (left, LSB, result, LSB, shCount);
- else
- shiftL2Left2Result (left, LSB, result, LSB, shCount);
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftLLong - shift left one long from left to result */
-/* offl = LSB or MSB16 */
-/*-----------------------------------------------------------------*/
-static void
-shiftLLong (operand * left, operand * result, int offr)
-{
- char *l;
- int size = AOP_SIZE (result);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (size >= LSB + offr)
- {
- l = aopGet (AOP (left), LSB, FALSE, FALSE);
- MOVA (l);
- emitcode ("add", "a,acc");
- if (sameRegs (AOP (left), AOP (result)) &&
- size >= MSB16 + offr && offr != LSB)
- emitcode ("xch", "a,%s",
- aopGet (AOP (left), LSB + offr, FALSE, FALSE));
- else
- aopPut (AOP (result), "a", LSB + offr);
- }
-
- if (size >= MSB16 + offr)
- {
- if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB16 + offr && offr != LSB))
- {
- l = aopGet (AOP (left), MSB16, FALSE, FALSE);
- MOVA (l);
- }
- emitcode ("rlc", "a");
- if (sameRegs (AOP (left), AOP (result)) &&
- size >= MSB24 + offr && offr != LSB)
- emitcode ("xch", "a,%s",
- aopGet (AOP (left), MSB16 + offr, FALSE, FALSE));
- else
- aopPut (AOP (result), "a", MSB16 + offr);
- }
-
- if (size >= MSB24 + offr)
- {
- if (!(sameRegs (AOP (left), AOP (left)) && size >= MSB24 + offr && offr != LSB))
- {
- l = aopGet (AOP (left), MSB24, FALSE, FALSE);
- MOVA (l);
- }
- emitcode ("rlc", "a");
- if (sameRegs (AOP (left), AOP (result)) &&
- size >= MSB32 + offr && offr != LSB)
- emitcode ("xch", "a,%s",
- aopGet (AOP (left), MSB24 + offr, FALSE, FALSE));
- else
- aopPut (AOP (result), "a", MSB24 + offr);
- }
-
- if (size > MSB32 + offr)
- {
- if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB32 + offr && offr != LSB))
- {
- l = aopGet (AOP (left), MSB32, FALSE, FALSE);
- MOVA (l);
- }
- emitcode ("rlc", "a");
- aopPut (AOP (result), "a", MSB32 + offr);
- }
- if (offr != LSB)
- aopPut (AOP (result), zero, LSB);
-}
-
-/*-----------------------------------------------------------------*/
-/* genlshFour - shift four byte by a known amount != 0 */
-/*-----------------------------------------------------------------*/
-static void
-genlshFour (operand * result, operand * left, int shCount)
-{
- int size;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- size = AOP_SIZE (result);
-
- /* if shifting more that 3 bytes */
- if (shCount >= 24)
- {
- shCount -= 24;
- if (shCount)
- /* lowest order of left goes to the highest
- order of the destination */
- shiftL1Left2Result (left, LSB, result, MSB32, shCount);
- else
- movLeft2Result (left, LSB, result, MSB32, 0);
- aopPut (AOP (result), zero, LSB);
- aopPut (AOP (result), zero, MSB16);
- aopPut (AOP (result), zero, MSB32);
- return;
- }
-
- /* more than two bytes */
- else if (shCount >= 16)
- {
- /* lower order two bytes goes to higher order two bytes */
- shCount -= 16;
- /* if some more remaining */
- if (shCount)
- shiftL2Left2Result (left, LSB, result, MSB24, shCount);
- else
- {
- movLeft2Result (left, MSB16, result, MSB32, 0);
- movLeft2Result (left, LSB, result, MSB24, 0);
- }
- aopPut (AOP (result), zero, MSB16);
- aopPut (AOP (result), zero, LSB);
- return;
- }
-
- /* if more than 1 byte */
- else if (shCount >= 8)
- {
- /* lower order three bytes goes to higher order three bytes */
- shCount -= 8;
- if (size == 2)
- {
- if (shCount)
- shiftL1Left2Result (left, LSB, result, MSB16, shCount);
- else
- movLeft2Result (left, LSB, result, MSB16, 0);
- }
- else
- { /* size = 4 */
- if (shCount == 0)
- {
- movLeft2Result (left, MSB24, result, MSB32, 0);
- movLeft2Result (left, MSB16, result, MSB24, 0);
- movLeft2Result (left, LSB, result, MSB16, 0);
- aopPut (AOP (result), zero, LSB);
- }
- else if (shCount == 1)
- shiftLLong (left, result, MSB16);
- else
- {
- shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
- shiftL1Left2Result (left, LSB, result, MSB16, shCount);
- shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);
- aopPut (AOP (result), zero, LSB);
- }
- }
- }
-
- /* 1 <= shCount <= 7 */
- else if (shCount <= 2)
- {
- shiftLLong (left, result, LSB);
- if (shCount == 2)
- shiftLLong (result, result, LSB);
- }
- /* 3 <= shCount <= 7, optimize */
- else
- {
- shiftL2Left2Result (left, MSB24, result, MSB24, shCount);
- shiftRLeftOrResult (left, MSB16, result, MSB24, 8 - shCount);
- shiftL2Left2Result (left, LSB, result, LSB, shCount);
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* genLeftShiftLiteral - left shifting by known count */
-/*-----------------------------------------------------------------*/
-static void
-genLeftShiftLiteral (operand * left,
- operand * right,
- operand * result,
- iCode * ic)
-{
- int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
- int size;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- freeAsmop (right, NULL, ic, TRUE);
-
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- size = getSize (operandType (result));
-
-#if VIEW_SIZE
- emitcode ("; shift left ", "result %d, left %d", size,
- AOP_SIZE (left));
-#endif
-
- /* I suppose that the left size >= result size */
- if (shCount == 0)
- {
- while (size--)
- {
- movLeft2Result (left, size, result, size, 0);
- }
- }
-
- else if (shCount >= (size * 8))
- while (size--)
- aopPut (AOP (result), zero, size);
- else
- {
- switch (size)
- {
- case 1:
- genlshOne (result, left, shCount);
- break;
-
- case 2:
- case 3:
- genlshTwo (result, left, shCount);
- break;
-
- case 4:
- genlshFour (result, left, shCount);
- break;
- }
- }
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genLeftShift - generates code for left shifting */
-/*-----------------------------------------------------------------*/
-static void
-genLeftShift (iCode * ic)
-{
- operand *left, *right, *result;
- int size, offset;
- char *l;
- symbol *tlbl, *tlbl1;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- right = IC_RIGHT (ic);
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
-
- aopOp (right, ic, FALSE);
-
- /* if the shift count is known then do it
- as efficiently as possible */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- genLeftShiftLiteral (left, right, result, ic);
- return;
- }
-
- /* shift count is unknown then we have to form
- a loop get the loop count in B : Note: we take
- only the lower order byte since shifting
- more that 32 bits make no sense anyway, ( the
- largest size of an object can be only 32 bits ) */
-
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- emitcode ("inc", "b");
- freeAsmop (right, NULL, ic, TRUE);
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- /* now move the left to the result if they are not the
- same */
- if (!sameRegs (AOP (left), AOP (result)) &&
- AOP_SIZE (result) > 1)
- {
-
- size = AOP_SIZE (result);
- offset = 0;
- while (size--)
- {
- l = aopGet (AOP (left), offset, FALSE, TRUE);
- if (*l == '@' && (IS_AOP_PREG (result)))
- {
-
- emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offset);
- }
- else
- aopPut (AOP (result), l, offset);
- offset++;
- }
- }
-
- tlbl = newiTempLabel (NULL);
- size = AOP_SIZE (result);
- offset = 0;
- tlbl1 = newiTempLabel (NULL);
-
- /* if it is only one byte then */
- if (size == 1)
- {
- symbol *tlbl1 = newiTempLabel (NULL);
-
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("sjmp", "%05d_DS_", tlbl1->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- emitcode ("add", "a,acc");
- emitcode ("", "%05d_DS_:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d_DS_", tlbl->key + 100);
- aopPut (AOP (result), "a", 0);
- goto release;
- }
-
- reAdjustPreg (AOP (result));
-
- emitcode ("sjmp", "%05d_DS_", tlbl1->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- l = aopGet (AOP (result), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("add", "a,acc");
- aopPut (AOP (result), "a", offset++);
- while (--size)
- {
- l = aopGet (AOP (result), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("rlc", "a");
- aopPut (AOP (result), "a", offset++);
- }
- reAdjustPreg (AOP (result));
-
- emitcode ("", "%05d_DS_:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d_DS_", tlbl->key + 100);
-release:
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genrshOne - right shift a one byte quantity by known count */
-/*-----------------------------------------------------------------*/
-static void
-genrshOne (operand * result, operand * left,
- int shCount, int sign)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- shiftR1Left2Result (left, LSB, result, LSB, shCount, sign);
-}
-
-/*-----------------------------------------------------------------*/
-/* genrshTwo - right shift two bytes by known amount != 0 */
-/*-----------------------------------------------------------------*/
-static void
-genrshTwo (operand * result, operand * left,
- int shCount, int sign)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if shCount >= 8 */
- if (shCount >= 8)
- {
- shCount -= 8;
- if (shCount)
- shiftR1Left2Result (left, MSB16, result, LSB,
- shCount, sign);
- else
- movLeft2Result (left, MSB16, result, LSB, sign);
- addSign (result, MSB16, sign);
- }
-
- /* 1 <= shCount <= 7 */
- else
- shiftR2Left2Result (left, LSB, result, LSB, shCount, sign);
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftRLong - shift right one long from left to result */
-/* offl = LSB or MSB16 */
-/*-----------------------------------------------------------------*/
-static void
-shiftRLong (operand * left, int offl,
- operand * result, int sign)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (!sign)
- emitcode ("clr", "c");
- MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
- if (sign)
- emitcode ("mov", "c,acc.7");
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", MSB32 - offl);
- if (offl == MSB16)
- /* add sign of "a" */
- addSign (result, MSB32, sign);
-
- MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", MSB24 - offl);
-
- MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", MSB16 - offl);
-
- if (offl == LSB)
- {
- MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", LSB);
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* genrshFour - shift four byte by a known amount != 0 */
-/*-----------------------------------------------------------------*/
-static void
-genrshFour (operand * result, operand * left,
- int shCount, int sign)
-{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if shifting more that 3 bytes */
- if (shCount >= 24)
- {
- shCount -= 24;
- if (shCount)
- shiftR1Left2Result (left, MSB32, result, LSB, shCount, sign);
- else
- movLeft2Result (left, MSB32, result, LSB, sign);
- addSign (result, MSB16, sign);
- }
- else if (shCount >= 16)
- {
- shCount -= 16;
- if (shCount)
- shiftR2Left2Result (left, MSB24, result, LSB, shCount, sign);
- else
- {
- movLeft2Result (left, MSB24, result, LSB, 0);
- movLeft2Result (left, MSB32, result, MSB16, sign);
- }
- addSign (result, MSB24, sign);
- }
- else if (shCount >= 8)
- {
- shCount -= 8;
- if (shCount == 1)
- shiftRLong (left, MSB16, result, sign);
- else if (shCount == 0)
- {
- movLeft2Result (left, MSB16, result, LSB, 0);
- movLeft2Result (left, MSB24, result, MSB16, 0);
- movLeft2Result (left, MSB32, result, MSB24, sign);
- addSign (result, MSB32, sign);
- }
- else
- {
- shiftR2Left2Result (left, MSB16, result, LSB, shCount, 0);
- shiftLLeftOrResult (left, MSB32, result, MSB16, 8 - shCount);
- /* the last shift is signed */
- shiftR1Left2Result (left, MSB32, result, MSB24, shCount, sign);
- addSign (result, MSB32, sign);
- }
- }
- else
- { /* 1 <= shCount <= 7 */
- if (shCount <= 2)
- {
- shiftRLong (left, LSB, result, sign);
- if (shCount == 2)
- shiftRLong (result, LSB, result, sign);
- }
- else
- {
- shiftR2Left2Result (left, LSB, result, LSB, shCount, 0);
- shiftLLeftOrResult (left, MSB24, result, MSB16, 8 - shCount);
- shiftR2Left2Result (left, MSB24, result, MSB24, shCount, sign);
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* genRightShiftLiteral - right shifting by known count */
-/*-----------------------------------------------------------------*/
-static void
-genRightShiftLiteral (operand * left,
- operand * right,
- operand * result,
- iCode * ic,
- int sign)
-{
- int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
- int size;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- freeAsmop (right, NULL, ic, TRUE);
-
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
-#if VIEW_SIZE
- emitcode ("; shift right ", "result %d, left %d", AOP_SIZE (result),
- AOP_SIZE (left));
-#endif
-
- size = getDataSize (left);
- /* test the LEFT size !!! */
-
- /* I suppose that the left size >= result size */
- if (shCount == 0)
- {
- size = getDataSize (result);
- while (size--)
- movLeft2Result (left, size, result, size, 0);
- }
-
- else if (shCount >= (size * 8))
- {
- if (sign)
- /* get sign in acc.7 */
- MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE));
- addSign (result, LSB, sign);
- }
- else
- {
- switch (size)
- {
- case 1:
- genrshOne (result, left, shCount, sign);
- break;
-
- case 2:
- genrshTwo (result, left, shCount, sign);
- break;
-
- case 4:
- genrshFour (result, left, shCount, sign);
- break;
- default:
- break;
- }
-
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* genSignedRightShift - right shift of signed number */
-/*-----------------------------------------------------------------*/
-static void
-genSignedRightShift (iCode * ic)
-{
- operand *right, *left, *result;
- int size, offset;
- char *l;
- symbol *tlbl, *tlbl1;
-
- /* we do it the hard way put the shift count in b
- and loop thru preserving the sign */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- right = IC_RIGHT (ic);
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
-
- aopOp (right, ic, FALSE);
-
-
- if (AOP_TYPE (right) == AOP_LIT)
- {
- genRightShiftLiteral (left, right, result, ic, 1);
- return;
- }
- /* shift count is unknown then we have to form
- a loop get the loop count in B : Note: we take
- only the lower order byte since shifting
- more that 32 bits make no sense anyway, ( the
- largest size of an object can be only 32 bits ) */
-
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- emitcode ("inc", "b");
- freeAsmop (right, NULL, ic, TRUE);
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- /* now move the left to the result if they are not the
- same */
- if (!sameRegs (AOP (left), AOP (result)) &&
- AOP_SIZE (result) > 1)
- {
-
- size = AOP_SIZE (result);
- offset = 0;
- while (size--)
- {
- l = aopGet (AOP (left), offset, FALSE, TRUE);
- if (*l == '@' && IS_AOP_PREG (result))
- {
-
- emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offset);
- }
- else
- aopPut (AOP (result), l, offset);
- offset++;
- }
- }
-
- /* mov the highest order bit to OVR */
- tlbl = newiTempLabel (NULL);
- tlbl1 = newiTempLabel (NULL);
-
- size = AOP_SIZE (result);
- offset = size - 1;
- emitcode ("mov", "a,%s", aopGet (AOP (left), offset, FALSE, FALSE));
- emitcode ("rlc", "a");
- emitcode ("mov", "ov,c");
- /* if it is only one byte then */
- if (size == 1)
- {
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("sjmp", "%05d_DS_", tlbl1->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- emitcode ("mov", "c,ov");
- emitcode ("rrc", "a");
- emitcode ("", "%05d_DS_:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d_DS_", tlbl->key + 100);
- aopPut (AOP (result), "a", 0);
- goto release;
- }
-
- reAdjustPreg (AOP (result));
- emitcode ("sjmp", "%05d_DS_", tlbl1->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- emitcode ("mov", "c,ov");
- while (size--)
- {
- l = aopGet (AOP (result), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", offset--);
- }
- reAdjustPreg (AOP (result));
- emitcode ("", "%05d_DS_:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d_DS_", tlbl->key + 100);
-
-release:
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genRightShift - generate code for right shifting */
-/*-----------------------------------------------------------------*/
-static void
-genRightShift (iCode * ic)
-{
- operand *right, *left, *result;
- sym_link *retype;
- int size, offset;
- char *l;
- symbol *tlbl, *tlbl1;
-
- /* if signed then we do it the hard way preserve the
- sign bit moving it inwards */
- retype = getSpec (operandType (IC_RESULT (ic)));
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- if (!SPEC_USIGN (retype))
- {
- genSignedRightShift (ic);
- return;
- }
-
- /* signed & unsigned types are treated the same : i.e. the
- signed is NOT propagated inwards : quoting from the
- ANSI - standard : "for E1 >> E2, is equivalent to division
- by 2**E2 if unsigned or if it has a non-negative value,
- otherwise the result is implementation defined ", MY definition
- is that the sign does not get propagated */
-
- right = IC_RIGHT (ic);
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
-
- aopOp (right, ic, FALSE);
-
- /* if the shift count is known then do it
- as efficiently as possible */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- genRightShiftLiteral (left, right, result, ic, 0);
- return;
- }
-
- /* shift count is unknown then we have to form
- a loop get the loop count in B : Note: we take
- only the lower order byte since shifting
- more that 32 bits make no sense anyway, ( the
- largest size of an object can be only 32 bits ) */
-
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- emitcode ("inc", "b");
- freeAsmop (right, NULL, ic, TRUE);
- aopOp (left, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- /* now move the left to the result if they are not the
- same */
- if (!sameRegs (AOP (left), AOP (result)) &&
- AOP_SIZE (result) > 1)
- {
-
- size = AOP_SIZE (result);
- offset = 0;
- while (size--)
- {
- l = aopGet (AOP (left), offset, FALSE, TRUE);
- if (*l == '@' && IS_AOP_PREG (result))
- {
-
- emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offset);
- }
- else
- aopPut (AOP (result), l, offset);
- offset++;
- }
- }
-
- tlbl = newiTempLabel (NULL);
- tlbl1 = newiTempLabel (NULL);
- size = AOP_SIZE (result);
- offset = size - 1;
-
- /* if it is only one byte then */
- if (size == 1)
- {
- l = aopGet (AOP (left), 0, FALSE, FALSE);
- MOVA (l);
- emitcode ("sjmp", "%05d_DS_", tlbl1->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- CLRC;
- emitcode ("rrc", "a");
- emitcode ("", "%05d_DS_:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d_DS_", tlbl->key + 100);
- aopPut (AOP (result), "a", 0);
- goto release;
- }
-
- reAdjustPreg (AOP (result));
- emitcode ("sjmp", "%05d_DS_", tlbl1->key + 100);
- emitcode ("", "%05d_DS_:", tlbl->key + 100);
- CLRC;
- while (size--)
- {
- l = aopGet (AOP (result), offset, FALSE, FALSE);
- MOVA (l);
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", offset--);
- }
- reAdjustPreg (AOP (result));
-
- emitcode ("", "%05d_DS_:", tlbl1->key + 100);
- emitcode ("djnz", "b,%05d_DS_", tlbl->key + 100);
-
-release:
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genUnpackBits - generates code for unpacking bits */
-/*-----------------------------------------------------------------*/
-static void
-genUnpackBits (operand * result, char *rname, int ptype)
-{
- int shCnt;
- int rlen = 0;
- sym_link *etype;
- int offset = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- etype = getSpec (operandType (result));
-
- /* read the first byte */
- switch (ptype)
- {
-
- case POINTER:
- case IPOINTER:
- emitcode ("mov", "a,@%s", rname);
- break;
-
- case PPOINTER:
- emitcode ("movx", "a,@%s", rname);
- break;
-
- case FPOINTER:
- emitcode ("movx", "a,@dptr");
- break;
-
- case CPOINTER:
- emitcode ("clr", "a");
- emitcode ("movc", "a", "@a+dptr");
- break;
-
- case GPOINTER:
- emitcode ("lcall", "__gptrget");
- break;
- }
-
- /* if we have bitdisplacement then it fits */
- /* into this byte completely or if length is */
- /* less than a byte */
- if ((shCnt = SPEC_BSTR (etype)) ||
- (SPEC_BLEN (etype) <= 8))
- {
-
- /* shift right acc */
- AccRsh (shCnt);
-
- emitcode ("anl", "a,#0x%02x",
- ((unsigned char) -1) >> (8 - SPEC_BLEN (etype)));
- aopPut (AOP (result), "a", offset);
- return;
- }
-
- /* bit field did not fit in a byte */
- rlen = SPEC_BLEN (etype) - 8;
- aopPut (AOP (result), "a", offset++);
-
- while (1)
- {
-
- switch (ptype)
- {
- case POINTER:
- case IPOINTER:
- emitcode ("inc", "%s", rname);
- emitcode ("mov", "a,@%s", rname);
- break;
-
- case PPOINTER:
- emitcode ("inc", "%s", rname);
- emitcode ("movx", "a,@%s", rname);
- break;
-
- case FPOINTER:
- emitcode ("inc", "dptr");
- emitcode ("movx", "a,@dptr");
- break;
-
- case CPOINTER:
- emitcode ("clr", "a");
- emitcode ("inc", "dptr");
- emitcode ("movc", "a", "@a+dptr");
- break;
-
- case GPOINTER:
- emitcode ("inc", "dptr");
- emitcode ("lcall", "__gptrget");
- break;
- }
-
- rlen -= 8;
- /* if we are done */
- if (rlen <= 0)
- break;
-
- aopPut (AOP (result), "a", offset++);
-
- }
-
- if (rlen)
- {
- emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (-rlen));
- aopPut (AOP (result), "a", offset);
- }
-
- return;
-}
-
-
-/*-----------------------------------------------------------------*/
-/* genDataPointerGet - generates code when ptr offset is known */
-/*-----------------------------------------------------------------*/
-static void
-genDataPointerGet (operand * left,
- operand * result,
- iCode * ic)
-{
- char *l;
- char buffer[256];
- int size, offset = 0;
- aopOp (result, ic, TRUE);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- /* get the string representation of the name */
- l = aopGet (AOP (left), 0, FALSE, TRUE);
- size = AOP_SIZE (result);
- // tsd, was l+1 - the underline `_' prefix was being stripped
- while (size--)
- {
- if (offset)
- sprintf (buffer, "(%s + %d)", l, offset);
- else
- sprintf (buffer, "%s", l);
- aopPut (AOP (result), buffer, offset++);
- }
-
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genNearPointerGet - emitcode for near pointer fetch */
-/*-----------------------------------------------------------------*/
-static void
-genNearPointerGet (operand * left,
- operand * result,
- iCode * ic)
-{
- asmop *aop = NULL;
- regs *preg = NULL;
- char *rname;
- sym_link *rtype, *retype;
- sym_link *ltype = operandType (left);
- char buffer[80];
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- rtype = operandType (result);
- retype = getSpec (rtype);
-
- aopOp (left, ic, FALSE);
-
- /* if left is rematerialisable and
- result is not bit variable type and
- the left is pointer to data space i.e
- lower 128 bytes of space */
- if (AOP_TYPE (left) == AOP_IMMD &&
- !IS_BITVAR (retype) &&
- DCL_TYPE (ltype) == POINTER)
- {
- genDataPointerGet (left, result, ic);
- return;
- }
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG (AOP (left)))
- {
- /* otherwise get a free pointer register */
- aop = newAsmop (0);
- preg = getFreePtr (ic, &aop, FALSE);
- emitcode ("mov", "%s,%s",
- preg->name,
- aopGet (AOP (left), 0, FALSE, TRUE));
- rname = preg->name;
- }
- else
- rname = aopGet (AOP (left), 0, FALSE, FALSE);
-
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR (retype))
- genUnpackBits (result, rname, POINTER);
- else
- {
- /* we have can just get the values */
- int size = AOP_SIZE (result);
- int offset = 0;
-
- while (size--)
- {
- if (IS_AOP_PREG (result) || AOP_TYPE (result) == AOP_STK)
- {
-
- emitcode ("mov", "a,@%s", rname);
- aopPut (AOP (result), "a", offset);
- }
- else
- {
- sprintf (buffer, "@%s", rname);
- aopPut (AOP (result), buffer, offset);
- }
- offset++;
- if (size)
- emitcode ("inc", "%s", rname);
- }
- }
-
- /* now some housekeeping stuff */
- if (aop)
- {
- /* we had to allocate for this iCode */
- freeAsmop (NULL, aop, ic, TRUE);
- }
- else
- {
- /* we did not allocate which means left
- already in a pointer register, then
- if size > 0 && this could be used again
- we have to point it back to where it
- belongs */
- if (AOP_SIZE (result) > 1 &&
- !OP_SYMBOL (left)->remat &&
- (OP_SYMBOL (left)->liveTo > ic->seq ||
- ic->depth))
- {
- int size = AOP_SIZE (result) - 1;
- while (size--)
- emitcode ("dec", "%s", rname);
- }
- }
-
- /* done */
- freeAsmop (result, NULL, ic, TRUE);
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genPagedPointerGet - emitcode for paged pointer fetch */
-/*-----------------------------------------------------------------*/
-static void
-genPagedPointerGet (operand * left,
- operand * result,
- iCode * ic)
-{
- asmop *aop = NULL;
- regs *preg = NULL;
- char *rname;
- sym_link *rtype, *retype;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- rtype = operandType (result);
- retype = getSpec (rtype);
-
- aopOp (left, ic, FALSE);
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG (AOP (left)))
- {
- /* otherwise get a free pointer register */
- aop = newAsmop (0);
- preg = getFreePtr (ic, &aop, FALSE);
- emitcode ("mov", "%s,%s",
- preg->name,
- aopGet (AOP (left), 0, FALSE, TRUE));
- rname = preg->name;
- }
- else
- rname = aopGet (AOP (left), 0, FALSE, FALSE);
-
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR (retype))
- genUnpackBits (result, rname, PPOINTER);
- else
- {
- /* we have can just get the values */
- int size = AOP_SIZE (result);
- int offset = 0;
-
- while (size--)
- {
-
- emitcode ("movx", "a,@%s", rname);
- aopPut (AOP (result), "a", offset);
-
- offset++;
-
- if (size)
- emitcode ("inc", "%s", rname);
- }
- }
-
- /* now some housekeeping stuff */
- if (aop)
- {
- /* we had to allocate for this iCode */
- freeAsmop (NULL, aop, ic, TRUE);
- }
- else
- {
- /* we did not allocate which means left
- already in a pointer register, then
- if size > 0 && this could be used again
- we have to point it back to where it
- belongs */
- if (AOP_SIZE (result) > 1 &&
- !OP_SYMBOL (left)->remat &&
- (OP_SYMBOL (left)->liveTo > ic->seq ||
- ic->depth))
- {
- int size = AOP_SIZE (result) - 1;
- while (size--)
- emitcode ("dec", "%s", rname);
- }
- }
-
- /* done */
- freeAsmop (result, NULL, ic, TRUE);
-
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genFarPointerGet - gget value from far space */
-/*-----------------------------------------------------------------*/
-static void
-genFarPointerGet (operand * left,
- operand * result, iCode * ic)
-{
- int size, offset;
- sym_link *retype = getSpec (operandType (result));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp (left, ic, 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 this is remateriazable */
- if (AOP_TYPE (left) == AOP_IMMD)
- emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
- else
- { /* we need to get it byte by byte */
- emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE));
- emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE));
- if (options.model == MODEL_FLAT24)
- {
- emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE));
- }
- }
- }
- /* so dptr know contains the address */
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR (retype))
- genUnpackBits (result, "dptr", FPOINTER);
- else
- {
- size = AOP_SIZE (result);
- offset = 0;
-
- while (size--)
- {
- emitcode ("movx", "a,@dptr");
- aopPut (AOP (result), "a", offset++);
- if (size)
- emitcode ("inc", "dptr");
- }
- }
-
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* emitcodePointerGet - gget value from code space */
-/*-----------------------------------------------------------------*/
-static void
-emitcodePointerGet (operand * left,
- operand * result, iCode * ic)
-{
- int size, offset;
- sym_link *retype = getSpec (operandType (result));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp (left, ic, 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 this is remateriazable */
- if (AOP_TYPE (left) == AOP_IMMD)
- emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
- else
- { /* we need to get it byte by byte */
- emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE));
- emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE));
- if (options.model == MODEL_FLAT24)
- {
- emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE));
- }
- }
- }
- /* so dptr know contains the address */
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR (retype))
- genUnpackBits (result, "dptr", CPOINTER);
- else
- {
- size = AOP_SIZE (result);
- offset = 0;
-
- while (size--)
- {
- emitcode ("clr", "a");
- emitcode ("movc", "a,@a+dptr");
- aopPut (AOP (result), "a", offset++);
- if (size)
- emitcode ("inc", "dptr");
- }
- }
-
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genGenPointerGet - gget value from generic pointer space */
-/*-----------------------------------------------------------------*/
-static void
-genGenPointerGet (operand * left,
- operand * result, iCode * ic)
-{
- int size, offset;
- sym_link *retype = getSpec (operandType (result));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp (left, ic, 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 this is remateriazable */
- if (AOP_TYPE (left) == AOP_IMMD)
- {
- emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
- emitcode ("mov", "b,#%d", pointerCode (retype));
- }
- else
- { /* we need to get it byte by byte */
-
- emitcode ("movf", "%s,w", aopGet (AOP (left), 0, FALSE, FALSE));
- emitcode ("movwf", "FSR");
- /*
- emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
- emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
- if (options.model == MODEL_FLAT24)
- {
- emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
- emitcode("mov","b,%s",aopGet(AOP(left),3,FALSE,FALSE));
- }
- else
- {
- emitcode("mov","b,%s",aopGet(AOP(left),2,FALSE,FALSE));
- }
- */
- }
- }
- /* so dptr know contains the address */
- freeAsmop (left, NULL, ic, TRUE);
- aopOp (result, ic, FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR (retype))
- genUnpackBits (result, "dptr", GPOINTER);
- else
- {
- size = AOP_SIZE (result);
- offset = 0;
-
- while (size--)
- {
- //emitcode("lcall","__gptrget");
- emitcode ("movf", "indf,w");
- //aopPut(AOP(result),"a",offset++);
- emitcode ("movwf", "%s",
- aopGet (AOP (result), offset++, FALSE, FALSE));
- if (size)
- emitcode ("incf", "fsr,f");
- }
- }
-
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genPointerGet - generate code for pointer get */
-/*-----------------------------------------------------------------*/
-static void
-genPointerGet (iCode * ic)
-{
- operand *left, *result;
- sym_link *type, *etype;
- int p_type;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- left = IC_LEFT (ic);
- result = IC_RESULT (ic);
-
- /* depending on the type of pointer we need to
- move it to the correct pointer register */
- type = operandType (left);
- etype = getSpec (type);
- /* if left is of type of pointer then it is simple */
- if (IS_PTR (type) && !IS_FUNC (type->next))
- p_type = DCL_TYPE (type);
- else
- {
- /* we have to go by the storage class */
- p_type = PTR_TYPE (SPEC_OCLS (etype));
-
-/* if (SPEC_OCLS(etype)->codesp ) { */
-/* p_type = CPOINTER ; */
-/* } */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/* p_type = FPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
-/* p_type = PPOINTER; */
-/* else */
-/* if (SPEC_OCLS(etype) == idata ) */
-/* p_type = IPOINTER; */
-/* else */
-/* p_type = POINTER ; */
- }
-
- /* now that we have the pointer type we assign
- the pointer values */
- switch (p_type)
- {
-
- case POINTER:
- case IPOINTER:
- genNearPointerGet (left, result, ic);
- break;
-
- case PPOINTER:
- genPagedPointerGet (left, result, ic);
- break;
-
- case FPOINTER:
- genFarPointerGet (left, result, ic);
- break;
-
- case CPOINTER:
- emitcodePointerGet (left, result, ic);
- break;
-
- case GPOINTER:
- genGenPointerGet (left, result, ic);
- break;
- }
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genPackBits - generates code for packed bit storage */
-/*-----------------------------------------------------------------*/
-static void
-genPackBits (sym_link * etype,
- operand * right,
- char *rname, int p_type)
-{
- int shCount = 0;
- int offset = 0;
- int rLen = 0;
- int blen, bstr;
- char *l;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- blen = SPEC_BLEN (etype);
- bstr = SPEC_BSTR (etype);
-
- l = aopGet (AOP (right), offset++, FALSE, FALSE);
- MOVA (l);
-
- /* if the bit lenth is less than or */
- /* it exactly fits a byte then */
- if (SPEC_BLEN (etype) <= 8)
- {
- shCount = SPEC_BSTR (etype);
-
- /* shift left acc */
- AccLsh (shCount);
-
- if (SPEC_BLEN (etype) < 8)
- { /* if smaller than a byte */
-
-
- switch (p_type)
- {
- case POINTER:
- emitcode ("mov", "b,a");
- emitcode ("mov", "a,@%s", rname);
- break;
-
- case FPOINTER:
- emitcode ("mov", "b,a");
- emitcode ("movx", "a,@dptr");
- break;
-
- case GPOINTER:
- emitcode ("push", "b");
- emitcode ("push", "acc");
- emitcode ("lcall", "__gptrget");
- emitcode ("pop", "b");
- break;
- }
-
- emitcode ("anl", "a,#0x%02x", (unsigned char)
- ((unsigned char) (0xFF << (blen + bstr)) |
- (unsigned char) (0xFF >> (8 - bstr))));
- emitcode ("orl", "a,b");
- if (p_type == GPOINTER)
- emitcode ("pop", "b");
- }
- }
-
- switch (p_type)
- {
- case POINTER:
- emitcode ("mov", "@%s,a", rname);
- break;
-
- case FPOINTER:
- emitcode ("movx", "@dptr,a");
- break;
-
- case GPOINTER:
- DEBUGemitcode (";lcall", "__gptrput");
- break;
- }
-
- /* if we r done */
- if (SPEC_BLEN (etype) <= 8)
- return;
-
- emitcode ("inc", "%s", rname);
- rLen = SPEC_BLEN (etype);
-
- /* now generate for lengths greater than one byte */
- while (1)
- {
-
- l = aopGet (AOP (right), offset++, FALSE, TRUE);
-
- rLen -= 8;
- if (rLen <= 0)
- break;
-
- switch (p_type)
- {
- case POINTER:
- if (*l == '@')
- {
- MOVA (l);
- emitcode ("mov", "@%s,a", rname);
- }
- else
- emitcode ("mov", "@%s,%s", rname, l);
- break;
-
- case FPOINTER:
- MOVA (l);
- emitcode ("movx", "@dptr,a");
- break;
-
- case GPOINTER:
- MOVA (l);
- DEBUGemitcode (";lcall", "__gptrput");
- break;
- }
- emitcode ("inc", "%s", rname);
- }
-
- MOVA (l);
-
- /* last last was not complete */
- if (rLen)
- {
- /* save the byte & read byte */
- switch (p_type)
- {
- case POINTER:
- emitcode ("mov", "b,a");
- emitcode ("mov", "a,@%s", rname);
- break;
-
- case FPOINTER:
- emitcode ("mov", "b,a");
- emitcode ("movx", "a,@dptr");
- break;
-
- case GPOINTER:
- emitcode ("push", "b");
- emitcode ("push", "acc");
- emitcode ("lcall", "__gptrget");
- emitcode ("pop", "b");
- break;
- }
-
- emitcode ("anl", "a,#0x%02x", ((unsigned char) -1 << -rLen));
- emitcode ("orl", "a,b");
- }
-
- if (p_type == GPOINTER)
- emitcode ("pop", "b");
-
- switch (p_type)
- {
-
- case POINTER:
- emitcode ("mov", "@%s,a", rname);
- break;
-
- case FPOINTER:
- emitcode ("movx", "@dptr,a");
- break;
-
- case GPOINTER:
- DEBUGemitcode (";lcall", "__gptrput");
- break;
- }
-}
-/*-----------------------------------------------------------------*/
-/* genDataPointerSet - remat pointer to data space */
-/*-----------------------------------------------------------------*/
-static void
-genDataPointerSet (operand * right,
- operand * result,
- iCode * ic)
-{
- int size, offset = 0;
- char *l, buffer[256];
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp (right, ic, FALSE);
-
- l = aopGet (AOP (result), 0, FALSE, TRUE);
- size = AOP_SIZE (right);
- // tsd, was l+1 - the underline `_' prefix was being stripped
- while (size--)
- {
- if (offset)
- sprintf (buffer, "(%s + %d)", l, offset);
- else
- sprintf (buffer, "%s", l);
-
- if (AOP_TYPE (right) == AOP_LIT)
- {
- unsigned int lit = floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- lit = lit >> (8 * offset);
- if (lit)
- {
- emitcode ("movlw", "%s", lit);
- emitcode ("movwf", "%s", buffer);
- }
- else
- emitcode ("clrf", "%s", buffer);
- }
- else
- {
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("movwf", "%s", buffer);
- }
-
- offset++;
- }
-
- freeAsmop (right, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genNearPointerSet - emitcode for near pointer put */
-/*-----------------------------------------------------------------*/
-static void
-genNearPointerSet (operand * right,
- operand * result,
- iCode * ic)
-{
- asmop *aop = NULL;
- char *l;
- sym_link *retype;
- sym_link *ptype = operandType (result);
-
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- retype = getSpec (operandType (right));
-
- aopOp (result, ic, FALSE);
-
- /* if the result is rematerializable &
- in data space & not a bit variable */
- if (AOP_TYPE (result) == AOP_IMMD &&
- DCL_TYPE (ptype) == POINTER &&
- !IS_BITVAR (retype))
- {
- genDataPointerSet (right, result, ic);
- return;
- }
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG (AOP (result)))
- {
- /* otherwise get a free pointer register */
- //aop = newAsmop(0);
- //preg = getFreePtr(ic,&aop,FALSE);
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- //emitcode("mov","%s,%s",
- // preg->name,
- // aopGet(AOP(result),0,FALSE,TRUE));
- //rname = preg->name ;
- emitcode ("movwf", "fsr");
- } // else
- // rname = aopGet(AOP(result),0,FALSE,FALSE);
-
- freeAsmop (result, NULL, ic, TRUE);
- aopOp (right, ic, FALSE);
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR (retype))
- {
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "The programmer is obviously confused");
- //genPackBits (retype,right,rname,POINTER);
- exit (1);
- }
- else
- {
- /* we have can just get the values */
- int size = AOP_SIZE (right);
- int offset = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- while (size--)
- {
- l = aopGet (AOP (right), offset, FALSE, TRUE);
- if (*l == '@')
- {
- //MOVA(l);
- //emitcode("mov","@%s,a",rname);
- emitcode ("movf", "indf,w ;1");
- }
- else
- {
-
- if (AOP_TYPE (right) == AOP_LIT)
- {
- unsigned int lit = floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- if (lit)
- {
- emitcode ("movlw", "%s", l);
- emitcode ("movwf", "indf ;2");
- }
- else
- emitcode ("clrf", "indf");
- }
- else
- {
- emitcode ("movf", "%s,w", l);
- emitcode ("movwf", "indf ;2");
- }
- //emitcode("mov","@%s,%s",rname,l);
- }
- if (size)
- emitcode ("incf", "fsr,f ;3");
- //emitcode("inc","%s",rname);
- offset++;
- }
- }
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* now some housekeeping stuff */
- if (aop)
- {
- /* we had to allocate for this iCode */
- freeAsmop (NULL, aop, ic, TRUE);
- }
- else
- {
- /* we did not allocate which means left
- already in a pointer register, then
- if size > 0 && this could be used again
- we have to point it back to where it
- belongs */
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- if (AOP_SIZE (right) > 1 &&
- !OP_SYMBOL (result)->remat &&
- (OP_SYMBOL (result)->liveTo > ic->seq ||
- ic->depth))
- {
- int size = AOP_SIZE (right) - 1;
- while (size--)
- emitcode ("decf", "fsr,f");
- //emitcode("dec","%s",rname);
- }
- }
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* done */
- freeAsmop (right, NULL, ic, TRUE);
-
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genPagedPointerSet - emitcode for Paged pointer put */
-/*-----------------------------------------------------------------*/
-static void
-genPagedPointerSet (operand * right,
- operand * result,
- iCode * ic)
-{
- asmop *aop = NULL;
- regs *preg = NULL;
- char *rname, *l;
- sym_link *retype;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- retype = getSpec (operandType (right));
-
- aopOp (result, ic, FALSE);
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG (AOP (result)))
- {
- /* otherwise get a free pointer register */
- aop = newAsmop (0);
- preg = getFreePtr (ic, &aop, FALSE);
- emitcode ("mov", "%s,%s",
- preg->name,
- aopGet (AOP (result), 0, FALSE, TRUE));
- rname = preg->name;
- }
- else
- rname = aopGet (AOP (result), 0, FALSE, FALSE);
-
- freeAsmop (result, NULL, ic, TRUE);
- aopOp (right, ic, FALSE);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR (retype))
- genPackBits (retype, right, rname, PPOINTER);
- else
- {
- /* we have can just get the values */
- int size = AOP_SIZE (right);
- int offset = 0;
-
- while (size--)
- {
- l = aopGet (AOP (right), offset, FALSE, TRUE);
-
- MOVA (l);
- emitcode ("movx", "@%s,a", rname);
-
- if (size)
- emitcode ("inc", "%s", rname);
-
- offset++;
- }
- }
-
- /* now some housekeeping stuff */
- if (aop)
- {
- /* we had to allocate for this iCode */
- freeAsmop (NULL, aop, ic, TRUE);
- }
- else
- {
- /* we did not allocate which means left
- already in a pointer register, then
- if size > 0 && this could be used again
- we have to point it back to where it
- belongs */
- if (AOP_SIZE (right) > 1 &&
- !OP_SYMBOL (result)->remat &&
- (OP_SYMBOL (result)->liveTo > ic->seq ||
- ic->depth))
- {
- int size = AOP_SIZE (right) - 1;
- while (size--)
- emitcode ("dec", "%s", rname);
- }
- }
-
- /* done */
- freeAsmop (right, NULL, ic, TRUE);
-
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genFarPointerSet - set value from far space */
-/*-----------------------------------------------------------------*/
-static void
-genFarPointerSet (operand * right,
- operand * result, iCode * ic)
-{
- int size, offset;
- sym_link *retype = getSpec (operandType (right));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp (result, ic, FALSE);
-
- /* 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 this is remateriazable */
- if (AOP_TYPE (result) == AOP_IMMD)
- emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE));
- else
- { /* we need to get it byte by byte */
- emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE));
- emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE));
- if (options.model == MODEL_FLAT24)
- {
- emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE));
- }
- }
- }
- /* so dptr know contains the address */
- freeAsmop (result, NULL, ic, TRUE);
- aopOp (right, ic, FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR (retype))
- genPackBits (retype, right, "dptr", FPOINTER);
- else
- {
- size = AOP_SIZE (right);
- offset = 0;
-
- while (size--)
- {
- char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
- MOVA (l);
- emitcode ("movx", "@dptr,a");
- if (size)
- emitcode ("inc", "dptr");
- }
- }
-
- freeAsmop (right, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genGenPointerSet - set value from generic pointer space */
-/*-----------------------------------------------------------------*/
-static void
-genGenPointerSet (operand * right,
- operand * result, iCode * ic)
-{
- int size, offset;
- sym_link *retype = getSpec (operandType (right));
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp (result, ic, FALSE);
-
- /* 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 this is remateriazable */
- if (AOP_TYPE (result) == AOP_IMMD)
- {
- emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE));
- emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
- }
- else
- { /* we need to get it byte by byte */
- char *l = aopGet (AOP (result), 0, FALSE, FALSE);
- if (strcmp ("FSR", l))
- emitcode ("movlw", "%s", aopGet (AOP (result), 0, FALSE, FALSE));
-
- emitcode ("movwf", "INDF");
- }
- }
- /* so dptr know contains the address */
- freeAsmop (result, NULL, ic, TRUE);
- aopOp (right, ic, FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR (retype))
- genPackBits (retype, right, "dptr", GPOINTER);
- else
- {
- size = AOP_SIZE (right);
- offset = 0;
-
- while (--size)
- {
- char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
- if (size)
- emitcode ("incf", "fsr,f");
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset++, FALSE, FALSE));
- emitcode ("movwf", "indf");
- //MOVA(l);
- //DEBUGemitcode(";lcall","__gptrput");
- //if (size)
- // emitcode("inc","dptr");
- }
- }
-
- freeAsmop (right, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genPointerSet - stores the value into a pointer location */
-/*-----------------------------------------------------------------*/
-static void
-genPointerSet (iCode * ic)
-{
- operand *right, *result;
- sym_link *type, *etype;
- int p_type;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- right = IC_RIGHT (ic);
- result = IC_RESULT (ic);
-
- /* depending on the type of pointer we need to
- move it to the correct pointer register */
- type = operandType (result);
- etype = getSpec (type);
- /* if left is of type of pointer then it is simple */
- if (IS_PTR (type) && !IS_FUNC (type->next))
- {
- p_type = DCL_TYPE (type);
- }
- else
- {
- /* we have to go by the storage class */
- p_type = PTR_TYPE (SPEC_OCLS (etype));
-
-/* if (SPEC_OCLS(etype)->codesp ) { */
-/* p_type = CPOINTER ; */
-/* } */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/* p_type = FPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
-/* p_type = PPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype) == idata ) */
-/* p_type = IPOINTER ; */
-/* else */
-/* p_type = POINTER ; */
- }
-
- /* now that we have the pointer type we assign
- the pointer values */
- switch (p_type)
- {
-
- case POINTER:
- case IPOINTER:
- genNearPointerSet (right, result, ic);
- break;
-
- case PPOINTER:
- genPagedPointerSet (right, result, ic);
- break;
-
- case FPOINTER:
- genFarPointerSet (right, result, ic);
- break;
-
- case GPOINTER:
- genGenPointerSet (right, result, ic);
- break;
- }
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genIfx - generate code for Ifx statement */
-/*-----------------------------------------------------------------*/
-static void
-genIfx (iCode * ic, iCode * popIc)
-{
- operand *cond = IC_COND (ic);
- int isbit = 0;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- aopOp (cond, ic, FALSE);
-
- /* get the value into acc */
- if (AOP_TYPE (cond) != AOP_CRY)
- toBoolean (cond);
- else
- isbit = 1;
- /* the result is now in the accumulator */
- freeAsmop (cond, NULL, ic, TRUE);
-
- /* if there was something to be popped then do it */
- if (popIc)
- genIpop (popIc);
-
- /* if the condition is a bit variable */
- if (isbit && IS_ITEMP (cond) &&
- SPIL_LOC (cond))
- {
- genIfxJump (ic, SPIL_LOC (cond)->rname);
- DEBUGemitcode ("; isbit SPIL_LOC", "%s", SPIL_LOC (cond)->rname);
- }
- else
- {
- /*
- if (isbit && !IS_ITEMP(cond))
- DEBUGemitcode ("; isbit OP_SYM","%s",OP_SYMBOL(cond)->rname);
- else
- DEBUGemitcode ("; isbit","a");
- */
-
- if (isbit && !IS_ITEMP (cond))
- genIfxJump (ic, OP_SYMBOL (cond)->rname);
- else
- genIfxJump (ic, "a");
- }
- ic->generated = 1;
-}
-
-/*-----------------------------------------------------------------*/
-/* genAddrOf - generates code for address of */
-/*-----------------------------------------------------------------*/
-static void
-genAddrOf (iCode * ic)
-{
- symbol *sym = OP_SYMBOL (IC_LEFT (ic));
- int size, offset;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp (IC_RESULT (ic), ic, FALSE);
-
- /* 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++);
- }
- }
-
- goto release;
- }
-
- /* object not on stack then we need the name */
- size = AOP_SIZE (IC_RESULT (ic));
- offset = 0;
-
- while (size--)
- {
- char s[SDCC_NAME_MAX];
- if (offset)
- sprintf (s, "#(%s >> %d)",
- sym->rname,
- offset * 8);
- else
- sprintf (s, "#%s", sym->rname);
- aopPut (AOP (IC_RESULT (ic)), s, offset++);
- }
-
-release:
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
-
-}
-
-#if 0
-/*-----------------------------------------------------------------*/
-/* genFarFarAssign - assignment when both are in far space */
-/*-----------------------------------------------------------------*/
-static void
-genFarFarAssign (operand * result, operand * right, iCode * ic)
-{
- int size = AOP_SIZE (right);
- int offset = 0;
- char *l;
- /* first push the right side on to the stack */
- while (size--)
- {
- l = aopGet (AOP (right), offset++, FALSE, FALSE);
- MOVA (l);
- emitcode ("push", "acc");
- }
-
- freeAsmop (right, NULL, ic, FALSE);
- /* now assign DPTR to result */
- aopOp (result, ic, FALSE);
- size = AOP_SIZE (result);
- while (size--)
- {
- emitcode ("pop", "acc");
- aopPut (AOP (result), "a", --offset);
- }
- freeAsmop (result, NULL, ic, FALSE);
-
-}
-#endif
-
-/*-----------------------------------------------------------------*/
-/* genAssign - generate code for assignment */
-/*-----------------------------------------------------------------*/
-static void
-genAssign (iCode * ic)
-{
- operand *result, *right;
- int size, offset;
- unsigned long lit = 0L;
-
- result = IC_RESULT (ic);
- right = IC_RIGHT (ic);
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- /* if they are the same */
- if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
- return;
-
- aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
-
- /* if they are the same registers */
- if (sameRegs (AOP (right), AOP (result)))
- goto release;
-
- /* if the result is a bit */
- if (AOP_TYPE (result) == AOP_CRY)
- {
-
- /* if the right size is a literal then
- we know what the value is */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- if (((int) operandLitValue (right)))
- emitcode ("bsf", "(%s >> 3),(%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- else
- emitcode ("bcf", "(%s >> 3),(%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- goto release;
- }
-
- /* the right is also a bit variable */
- if (AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("bcf", "(%s >> 3),(%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- emitcode ("btfsc", "(%s >> 3),(%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- emitcode ("bsf", "(%s >> 3),(%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- goto release;
- }
-
- /* we need to or */
- toBoolean (right);
- aopPut (AOP (result), "a", 0);
- goto release;
- }
-
- /* bit variables done */
- /* general case */
- size = AOP_SIZE (result);
- offset = 0;
- if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
- if ((AOP_TYPE (result) != AOP_REG) &&
- (AOP_TYPE (right) == AOP_LIT) &&
- !IS_FLOAT (operandType (right)) &&
- (lit < 256L))
- {
-
- while (size--)
- {
- if ((unsigned int) ((lit >> (size * 8)) & 0x0FFL) == 0)
- emitcode ("clrf", "%s", aopGet (AOP (result), size, FALSE, FALSE));
- else
- {
- emitcode ("movlw", "%s", aopGet (AOP (right), size, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (result), size, FALSE, FALSE));
- }
- }
- }
- else
- {
- while (size--)
- {
- if (AOP_TYPE (right) == AOP_LIT)
- emitcode ("movlw", "%s", aopGet (AOP (right), offset, FALSE, FALSE));
- else
- emitcode ("movf", "%s,w", aopGet (AOP (right), offset, FALSE, FALSE));
-
- emitcode ("movwf", "%s", aopGet (AOP (result), offset, FALSE, FALSE));
- offset++;
- }
- }
-
-release:
- freeAsmop (right, NULL, ic, FALSE);
- freeAsmop (result, NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genJumpTab - genrates code for jump table */
-/*-----------------------------------------------------------------*/
-static void
-genJumpTab (iCode * ic)
-{
- symbol *jtab;
- char *l;
-
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- aopOp (IC_JTCOND (ic), ic, FALSE);
- /* get the condition into accumulator */
- l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE);
- MOVA (l);
- /* multiply by three */
- emitcode ("add", "a,acc");
- emitcode ("add", "a,%s", aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE));
- freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
-
- jtab = newiTempLabel (NULL);
- emitcode ("mov", "dptr,#%05d_DS_", jtab->key + 100);
- emitcode ("jmp", "@a+dptr");
- emitcode ("", "%05d_DS_:", jtab->key + 100);
- /* now generate the jump labels */
- for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
- jtab = setNextItem (IC_JTLABELS (ic)))
- emitcode ("ljmp", "%05d_DS_", jtab->key + 100);
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genMixedOperation - gen code for operators between mixed types */
-/*-----------------------------------------------------------------*/
-/*
- TSD - Written for the PIC port - but this unfortunately is buggy.
- This routine is good in that it is able to efficiently promote
- types to different (larger) sizes. Unfortunately, the temporary
- variables that are optimized out by this routine are sometimes
- used in other places. So until I know how to really parse the
- iCode tree, I'm going to not be using this routine :(.
- */
-static int
-genMixedOperation (iCode * ic)
-{
-#if 0
- operand *result = IC_RESULT (ic);
- sym_link *ctype = operandType (IC_LEFT (ic));
- operand *right = IC_RIGHT (ic);
- int ret = 0;
- int big, small;
- int offset;
-
- iCode *nextic;
- operand *nextright = NULL, *nextleft = NULL, *nextresult = NULL;
-
- emitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- nextic = ic->next;
- if (!nextic)
- return 0;
-
- nextright = IC_RIGHT (nextic);
- nextleft = IC_LEFT (nextic);
- nextresult = IC_RESULT (nextic);
-
- aopOp (right, ic, FALSE);
- aopOp (result, ic, FALSE);
- aopOp (nextright, nextic, FALSE);
- aopOp (nextleft, nextic, FALSE);
- aopOp (nextresult, nextic, FALSE);
-
- if (sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (nextic))))
- {
-
- operand *t = right;
- right = nextright;
- nextright = t;
-
- emitcode (";remove right +", "");
-
- }
- else if (sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (nextic))))
- {
-/*
- operand *t = right;
- right = nextleft;
- nextleft = t;
- */
- emitcode (";remove left +", "");
- }
- else
- return 0;
-
- big = AOP_SIZE (nextleft);
- small = AOP_SIZE (nextright);
-
- switch (nextic->op)
- {
-
- case '+':
- emitcode (";optimize a +", "");
- /* if unsigned or not an integral type */
- if (AOP_TYPE (IC_LEFT (nextic)) == AOP_CRY)
- {
- emitcode (";add a bit to something", "");
- }
- else
- {
-
- emitcode ("movf", "%s,w", AOP (nextright)->aopu.aop_dir);
-
- if (!sameRegs (AOP (IC_LEFT (nextic)), AOP (IC_RESULT (nextic))))
- {
- emitcode ("addwf", "%s,w", AOP (nextleft)->aopu.aop_dir);
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (nextic)), 0, FALSE, FALSE));
- }
- else
- emitcode ("addwf", "%s,f", AOP (nextleft)->aopu.aop_dir);
-
- offset = 0;
- while (--big)
- {
-
- offset++;
-
- if (--small)
- {
- if (!sameRegs (AOP (IC_LEFT (nextic)), AOP (IC_RESULT (nextic))))
- {
- emitcode ("movf", "%s,w", aopGet (AOP (IC_LEFT (nextic)), offset, FALSE, FALSE));
- emitcode ("movwf", "%s,f", aopGet (AOP (IC_RESULT (nextic)), offset, FALSE, FALSE));
- }
-
- emitcode ("movf", "%s,w", aopGet (AOP (IC_LEFT (nextic)), offset, FALSE, FALSE));
- emitSKPNC;
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (IC_RIGHT (nextic))->aopu.aop_dir,
- AOP (IC_RIGHT (nextic))->aopu.aop_dir);
- emitcode (" incf", "%s,w", aopGet (AOP (IC_LEFT (nextic)), offset, FALSE, FALSE));
- emitcode ("movwf", "%s", aopGet (AOP (IC_RESULT (nextic)), offset, FALSE, FALSE));
-
- }
- else
- {
- emitcode ("rlf", "known_zero,w");
-
- /*
- if right is signed
- btfsc right,7
- addlw ff
- */
- if (!sameRegs (AOP (IC_LEFT (nextic)), AOP (IC_RESULT (nextic))))
- {
- emitcode ("addwf", "%s,w", aopGet (AOP (IC_LEFT (nextic)), offset, FALSE, FALSE));
- emitcode ("movwf", "%s,f", aopGet (AOP (IC_RESULT (nextic)), offset, FALSE, FALSE));
- }
- else
- {
- emitcode ("addwf", "%s,f", aopGet (AOP (IC_RESULT (nextic)), offset, FALSE, FALSE));
- }
- }
- }
- ret = 1;
- }
- }
- ret = 1;
-
-release:
- freeAsmop (right, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
- freeAsmop (nextright, NULL, ic, TRUE);
- freeAsmop (nextleft, NULL, ic, TRUE);
- if (ret)
- nextic->generated = 1;
-
- return ret;
-#else
- return 0;
-#endif
-}
-/*-----------------------------------------------------------------*/
-/* genCast - gen code for casting */
-/*-----------------------------------------------------------------*/
-static void
-genCast (iCode * ic)
-{
- operand *result = IC_RESULT (ic);
- sym_link *ctype = operandType (IC_LEFT (ic));
- operand *right = IC_RIGHT (ic);
- int size, offset;
-
- emitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
- /* if they are equivalent then do nothing */
- if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
- return;
-
- aopOp (right, ic, FALSE);
- aopOp (result, ic, FALSE);
-
- /* if the result is a bit */
- if (AOP_TYPE (result) == AOP_CRY)
- {
- /* if the right size is a literal then
- we know what the value is */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- emitcode ("; *** right is a lit", "%s %d", __FUNCTION__, __LINE__);
- if (((int) operandLitValue (right)))
- emitcode ("bsf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
- else
- emitcode ("bcf", "(%s >> 3), (%s & 7)",
- AOP (result)->aopu.aop_dir,
- AOP (result)->aopu.aop_dir);
-
- goto release;
- }
-
- /* the right is also a bit variable */
- if (AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("clrc", "");
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- aopPut (AOP (result), "c", 0);
- goto release;
- }
-
- /* we need to or */
- toBoolean (right);
- aopPut (AOP (result), "a", 0);
- goto release;
- }
-
- /* if they are the same size : or less */
- if (AOP_SIZE (result) <= AOP_SIZE (right))
- {
-
- /* if they are in the same place */
- if (sameRegs (AOP (right), AOP (result)))
- goto release;
-
- /* if they in different places then copy */
- size = AOP_SIZE (result);
- offset = 0;
- while (size--)
- {
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset);
- offset++;
- }
- goto release;
- }
-
-
- /* if the result is of type pointer */
- if (IS_PTR (ctype))
- {
-
- int p_type;
- sym_link *type = operandType (right);
- sym_link *etype = getSpec (type);
-
- /* pointer to generic pointer */
- if (IS_GENPTR (ctype))
- {
- char *l = zero;
-
- if (IS_PTR (type))
- p_type = DCL_TYPE (type);
- else
- {
- /* we have to go by the storage class */
- p_type = PTR_TYPE (SPEC_OCLS (etype));
-
-/* if (SPEC_OCLS(etype)->codesp ) */
-/* p_type = CPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/* p_type = FPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
-/* p_type = PPOINTER; */
-/* else */
-/* if (SPEC_OCLS(etype) == idata ) */
-/* p_type = IPOINTER ; */
-/* else */
-/* p_type = POINTER ; */
- }
-
- /* the first two bytes are known */
- size = GPTRSIZE - 1;
- offset = 0;
- while (size--)
- {
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset);
- offset++;
- }
- /* 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);
- \v
- }
- aopPut (AOP (result), l, GPTRSIZE - 1);
- goto release;
- }
-
- /* just copy the pointers */
- size = AOP_SIZE (result);
- offset = 0;
- while (size--)
- {
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset);
- offset++;
- }
- goto release;
- }
-
-
- if (AOP_TYPE (right) == AOP_CRY)
- {
- int offset = 1;
- size = AOP_SIZE (right);
-
- emitcode ("clrf", "%s ; %d", aopGet (AOP (result), 0, FALSE, FALSE), __LINE__);
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- emitcode ("incf", "%s,f", aopGet (AOP (result), 0, FALSE, FALSE), __LINE__);
- while (size--)
- {
- emitcode ("clrf", "%s", aopGet (AOP (result), offset++, FALSE, FALSE), __LINE__);
- }
- goto release;
- }
-
- /* so we now know that the size of destination is greater
- than the size of the source.
- Now, if the next iCode is an operator then we might be
- able to optimize the operation without performing a cast.
- */
- if (genMixedOperation (ic))
- goto release;
-
-
- /* we move to result for the size of source */
- size = AOP_SIZE (right);
- offset = 0;
- while (size--)
- {
- emitcode (";", "%d", __LINE__);
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset);
- offset++;
- }
-
- /* now depending on the sign of the destination */
- size = AOP_SIZE (result) - AOP_SIZE (right);
- /* if unsigned or not an integral type */
- if (SPEC_USIGN (ctype) || !IS_SPEC (ctype))
- {
- while (size--)
- emitcode ("clrf", "%s", aopGet (AOP (result), offset++, FALSE, FALSE));
- }
- else
- {
- /* we need to extend the sign :{ */
- //char *l = aopGet(AOP(right),AOP_SIZE(right) - 1,FALSE,FALSE);
- //MOVA(l);
-
- emitcode ("clrw", "");
- emitcode ("btfsc", "(%s >> 3), (%s & 7)",
- AOP (right)->aopu.aop_dir,
- AOP (right)->aopu.aop_dir);
- emitcode ("movlw", "0xff");
- while (size--)
- {
- emitcode ("movwf", "%s", aopGet (AOP (result), offset++, FALSE, FALSE));
- // aopPut(AOP(result),"a",offset++);
- }
-
- }
-
- /* we are done hurray !!!! */
-
-release:
- freeAsmop (right, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genDjnz - generate decrement & jump if not zero instrucion */
-/*-----------------------------------------------------------------*/
-static int
-genDjnz (iCode * ic, iCode * ifx)
-{
- symbol *lbl, *lbl1;
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- if (!ifx)
- return 0;
-
- /* if the if condition has a false label
- then we cannot save */
- if (IC_FALSE (ifx))
- return 0;
-
- /* if the minus is not of the form
- a = a - 1 */
- if (!isOperandEqual (IC_RESULT (ic), IC_LEFT (ic)) ||
- !IS_OP_LITERAL (IC_RIGHT (ic)))
- return 0;
-
- if (operandLitValue (IC_RIGHT (ic)) != 1)
- return 0;
-
- /* if the size of this greater than one then no
- saving */
- if (getSize (operandType (IC_RESULT (ic))) > 1)
- return 0;
-
- /* otherwise we can save BIG */
- lbl = newiTempLabel (NULL);
- lbl1 = newiTempLabel (NULL);
-
- aopOp (IC_RESULT (ic), ic, FALSE);
-
- if (IS_AOP_PREG (IC_RESULT (ic)))
- {
- emitcode ("dec", "%s",
- aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- emitcode ("jnz", "%05d_DS_", lbl->key + 100);
- }
- else
- {
- emitcode ("decfsz", "%s,f", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- emitcode ("goto", "_%05d_DS_", IC_TRUE (ifx)->key + 100 + labelOffset);
-
- }
-/* emitcode ("sjmp","%05d_DS_",lbl1->key+100); */
-/* emitcode ("","%05d_DS_:",lbl->key+100); */
-/* emitcode ("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100); */
-/* emitcode ("","%05d_DS_:",lbl1->key+100); */
-
-
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
- ifx->generated = 1;
- return 1;
-}
-
-/*-----------------------------------------------------------------*/
-/* genReceive - generate code for a receive iCode */
-/*-----------------------------------------------------------------*/
-static void
-genReceive (iCode * ic)
+int
+op_isLitLike (operand *op)
{
- DEBUGemitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
-
- 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 = fReturnSize - size;
- while (size--)
- {
- emitcode ("push", "%s", (strcmp (fReturn[fReturnSize - offset - 1], "a") ?
- fReturn[fReturnSize - offset - 1] : "acc"));
- offset++;
- }
- aopOp (IC_RESULT (ic), ic, 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);
- _G.accInUse--;
- assignResultValue (IC_RESULT (ic));
- }
-
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ assert (op);
+ if (aop_isLitLike (AOP(op))) return 1;
+ if (IS_FUNC(OP_SYM_TYPE(op))) return 1;
+ if (IS_PTR(OP_SYM_TYPE(op)) && AOP_TYPE(op) == AOP_PCODE && AOP(op)->aopu.pcop->type == PO_IMMEDIATE) return 1;
+ return 0;
}
-/*-----------------------------------------------------------------*/
-/* genpic14Code - generate code for pic14 based controllers */
-/*-----------------------------------------------------------------*/
-void
-genpic14Code (iCode * lic)
-{
- iCode *ic;
- int cln = 0;
-
- lineHead = lineCurr = NULL;
-
- /* if debug information required */
-/* if (options.debug && currFunc) { */
- if (currFunc)
- {
- cdbSymbol (currFunc, cdbFile, FALSE, TRUE);
- _G.debugLine = 1;
- if (IS_STATIC (currFunc->etype))
- emitcode ("", ";F%s$%s$0$0 %d", moduleName, currFunc->name, __LINE__);
- else
- emitcode ("", ";G$%s$0$0 %d", currFunc->name, __LINE__);
- _G.debugLine = 0;
- }
-
-
- for (ic = lic; ic; ic = ic->next)
- {
-
- DEBUGemitcode (";ic", "");
- if (cln != ic->lineno)
- {
- if (options.debug)
- {
- _G.debugLine = 1;
- emitcode ("", ";C$%s$%d$%d$%d ==.",
- FileBaseName (ic->filename), ic->lineno,
- ic->level, ic->block);
- _G.debugLine = 0;
- }
- emitcode (";", "%s %d", ic->filename, ic->lineno);
- cln = ic->lineno;
- }
- /* if the result is marked as
- spilt and rematerializable or code for
- this has already been generated then
- do nothing */
- if (resultRemat (ic) || ic->generated)
- continue;
-
- /* depending on the operation */
- switch (ic->op)
- {
- case '!':
- genNot (ic);
- break;
-
- case '~':
- genCpl (ic);
- break;
-
- case UNARYMINUS:
- genUminus (ic);
- break;
-
- case IPUSH:
- genIpush (ic);
- break;
-
- case IPOP:
- /* IPOP happens only when trying to restore a
- spilt live range, if there is an ifx statement
- following this pop then the if statement might
- be using some of the registers being popped which
- would destory the contents of the register so
- we need to check for this condition and handle it */
- if (ic->next &&
- ic->next->op == IFX &&
- regsInCommon (IC_LEFT (ic), IC_COND (ic->next)))
- genIfx (ic->next, ic);
- else
- genIpop (ic);
- break;
-
- case CALL:
- genCall (ic);
- break;
-
- case PCALL:
- genPcall (ic);
- break;
-
- case FUNCTION:
- genFunction (ic);
- break;
-
- case ENDFUNCTION:
- genEndFunction (ic);
- break;
-
- case RETURN:
- genRet (ic);
- break;
-
- case LABEL:
- genLabel (ic);
- break;
-
- case GOTO:
- genGoto (ic);
- break;
-
- case '+':
- genPlus (ic);
- break;
-
- case '-':
- if (!genDjnz (ic, ifxForOp (IC_RESULT (ic), ic)))
- genMinus (ic);
- break;
-
- case '*':
- genMult (ic);
- break;
-
- case '/':
- genDiv (ic);
- break;
-
- case '%':
- genMod (ic);
- break;
-
- case '>':
- genCmpGt (ic, ifxForOp (IC_RESULT (ic), ic));
- break;
-
- case '<':
- genCmpLt (ic, ifxForOp (IC_RESULT (ic), ic));
- break;
-
- case LE_OP:
- case GE_OP:
- case NE_OP:
-
- /* note these two are xlated by algebraic equivalence
- during parsing SDCC.y */
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "got '>=' or '<=' shouldn't have come here");
- break;
-
- case EQ_OP:
- genCmpEq (ic, ifxForOp (IC_RESULT (ic), ic));
- break;
-
- case AND_OP:
- genAndOp (ic);
- break;
-
- case OR_OP:
- genOrOp (ic);
- break;
-
- case '^':
- genXor (ic, ifxForOp (IC_RESULT (ic), ic));
- break;
-
- case '|':
- genOr (ic, ifxForOp (IC_RESULT (ic), ic));
- break;
-
- case BITWISEAND:
- genAnd (ic, ifxForOp (IC_RESULT (ic), ic));
- break;
-
- case INLINEASM:
- genInline (ic);
- break;
-
- case RRC:
- genRRC (ic);
- break;
-
- case RLC:
- genRLC (ic);
- break;
-
- case GETHBIT:
- genGetHbit (ic);
- break;
-
- case LEFT_OP:
- genLeftShift (ic);
- break;
-
- case RIGHT_OP:
- genRightShift (ic);
- break;
-
- case GET_VALUE_AT_ADDRESS:
- genPointerGet (ic);
- break;
-
- case '=':
- if (POINTER_SET (ic))
- genPointerSet (ic);
- else
- genAssign (ic);
- break;
-
- case IFX:
- genIfx (ic, NULL);
- break;
-
- case ADDRESS_OF:
- genAddrOf (ic);
- break;
-
- case JUMPTABLE:
- genJumpTab (ic);
- break;
-
- case CAST:
- genCast (ic);
- break;
-
- case RECEIVE:
- genReceive (ic);
- break;
-
- case SEND:
- addSet (&_G.sendSet, ic);
- break;
-
- default:
- ic = ic;
- /* piCode(ic,stdout); */
-
- }
- }
-
-
- /* now we are ready to call the
- peep hole optimizer */
- if (!options.nopeep)
- {
- printf ("peep hole optimizing\n");
- peepHole (&lineHead);
- }
- /* now do the actual printing */
- printLine (lineHead, codeOutFile);
- return;
-}
projects / fw / sdcc / blobdiff