git.gag.com Git - fw/sdcc/blob - src/pic/gen.c

   1 /*-------------------------------------------------------------------------
   2   gen.c - source file for code generation for pic
   3
   4   Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   5          and -  Jean-Louis VERN.jlvern@writeme.com (1999)
   6   Bug Fixes  -  Wojciech Stryjewski  wstryj1@tiger.lsu.edu (1999 v2.1.9a)
   7   PIC port   -  Scott Dattalo scott@dattalo.com (2000)
   8     cont'd   -  Raphael Neider <rneider AT web.de> (2005)
   9
  10   This program is free software; you can redistribute it and/or modify it
  11   under the terms of the GNU General Public License as published by the
  12   Free Software Foundation; either version 2, or (at your option) any
  13   later version.
  14
  15   This program is distributed in the hope that it will be useful,
  16   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18   GNU General Public License for more details.
  19
  20   You should have received a copy of the GNU General Public License
  21   along with this program; if not, write to the Free Software
  22   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23
  24   In other words, you are welcome to use, share and improve this program.
  25   You are forbidden to forbid anyone else to use, share and improve
  26   what you give them.   Help stamp out software-hoarding!
  27
  28   Notes:
  29   000123 mlh  Moved aopLiteral to SDCCglue.c to help the split
  30       Made everything static
  31 -------------------------------------------------------------------------*/
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include "SDCCglobl.h"
  38 #include "newalloc.h"
  39
  40 #include "common.h"
  41 #include "SDCCpeeph.h"
  42 #include "ralloc.h"
  43 #include "pcode.h"
  44 #include "gen.h"
  45 #include "glue.h"
  46
  47 /* The PIC port(s) need not differentiate between POINTER and FPOINTER. */
  48 #define PIC_IS_DATA_PTR(x)  (IS_DATA_PTR(x) || IS_FARPTR(x))
  49 #define PIC_IS_FARPTR(x)    (PIC_IS_DATA_PTR(x))
  50
  51 extern void genUMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
  52 extern void genSMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
  53 void genMult8X8_8 (operand *, operand *,operand *);
  54 extern void printpBlock(FILE *of, pBlock *pb);
  55
  56 static int labelOffset=0;
  57 extern int debug_verbose;
  58 extern int pic14_hasInterrupt;
  59 //static int optimized_for_speed = 0;
  60
  61 /* max_key keeps track of the largest label number used in
  62 a function. This is then used to adjust the label offset
  63 for the next function.
  64 */
  65 static int max_key=0;
  66 static int GpsuedoStkPtr=0;
  67 static int pic14_inISR = 0;
  68
  69 pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func);
  70 extern char *get_op( pCodeOp *pcop,char *buff,size_t buf_size);
  71 const char *AopType(short type);
  72
  73 #define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0x00ff)
  74
  75 /* this is the down and dirty file with all kinds of
  76 kludgy & hacky stuff. This is what it is all about
  77 CODE GENERATION for a specific MCU . some of the
  78 routines may be reusable, will have to see */
  79
  80 static char *zero = "0x00";
  81 static char *one  = "0x01";
  82 static char *spname = "sp";
  83
  84 char *fReturnpic14[] = {"temp1","temp2","temp3","temp4" };
  85 unsigned fReturnSizePic = 4; /* shared with ralloc.c */
  86 static char **fReturn = fReturnpic14;
  87
  88 //static char *accUse[] = {"a","b"};
  89
  90 //static short rbank = -1;
  91
  92 static struct {
  93     short r0Pushed;
  94     short r1Pushed;
  95     short accInUse;
  96     short inLine;
  97     short debugLine;
  98     short nRegsSaved;
  99     set *sendSet;
 100 } _G;
 101
 102 /* Resolved ifx structure. This structure stores information
 103 about an iCode ifx that makes it easier to generate code.
 104 */
 105 typedef struct resolvedIfx {
 106     symbol *lbl;     /* pointer to a label */
 107     int condition;   /* true or false ifx */
 108     int generated;   /* set true when the code associated with the ifx
 109                       * is generated */
 110 } resolvedIfx;
 111
 112 extern int pic14_ptrRegReq ;
 113 extern int pic14_nRegs;
 114 extern struct dbuf_s *codeOutBuf;
 115 static void saverbank (int, iCode *,bool);
 116
 117 static lineNode *lineHead = NULL;
 118 static lineNode *lineCurr = NULL;
 119
 120 #if 0
 121 static unsigned char   SLMask[] = {0xFF ,0xFE, 0xFC, 0xF8, 0xF0,
 122 0xE0, 0xC0, 0x80, 0x00};
 123 static unsigned char   SRMask[] = {0xFF, 0x7F, 0x3F, 0x1F, 0x0F,
 124 0x07, 0x03, 0x01, 0x00};
 125 #endif
 126
 127 static  pBlock *pb;
 128
 129 /*-----------------------------------------------------------------*/
 130 /*  my_powof2(n) - If `n' is an integaer power of 2, then the      */
 131 /*                 exponent of 2 is returned, otherwise -1 is      */
 132 /*                 returned.                                       */
 133 /* note that this is similar to the function `powof2' in SDCCsymt  */
 134 /* if(n == 2^y)                                                    */
 135 /*   return y;                                                     */
 136 /* return -1;                                                      */
 137 /*-----------------------------------------------------------------*/
 138 static int my_powof2 (unsigned long num)
 139 {
 140     if(num) {
 141         if( (num & (num-1)) == 0) {
 142             int nshifts = -1;
 143             while(num) {
 144                 num>>=1;
 145                 nshifts++;
 146             }
 147             return nshifts;
 148         }
 149     }
 150
 151     return -1;
 152 }
 153
 154 void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *result)
 155 {
 156
 157     DEBUGpic14_emitcode ("; ","line = %d result %s=%s, size=%d, left %s=%s, size=%d, right %s=%s, size=%d",
 158         line_no,
 159         ((result) ? AopType(AOP_TYPE(result)) : "-"),
 160         ((result) ? aopGet(AOP(result),0,TRUE,FALSE) : "-"),
 161         ((result) ? AOP_SIZE(result) : 0),
 162         ((left)   ? AopType(AOP_TYPE(left)) : "-"),
 163         ((left)   ? aopGet(AOP(left),0,TRUE,FALSE) : "-"),
 164         ((left)   ? AOP_SIZE(left) : 0),
 165         ((right)  ? AopType(AOP_TYPE(right)) : "-"),
 166         ((right)  ? aopGet(AOP(right),0,FALSE,FALSE) : "-"),
 167         ((right)  ? AOP_SIZE(right) : 0));
 168
 169 }
 170
 171 void DEBUGpic14_AopTypeSign(int line_no, operand *left, operand *right, operand *result)
 172 {
 173
 174     DEBUGpic14_emitcode ("; ","line = %d, signs: result %s=%c, left %s=%c, right %s=%c",
 175         line_no,
 176         ((result) ? AopType(AOP_TYPE(result)) : "-"),
 177         ((result) ? (SPEC_USIGN(operandType(result)) ? 'u' : 's') : '-'),
 178         ((left)   ? AopType(AOP_TYPE(left)) : "-"),
 179         ((left)   ? (SPEC_USIGN(operandType(left))   ? 'u' : 's') : '-'),
 180         ((right)  ? AopType(AOP_TYPE(right)) : "-"),
 181         ((right)  ? (SPEC_USIGN(operandType(right))  ? 'u' : 's') : '-'));
 182
 183 }
 184
 185 void DEBUGpic14_emitcode (char *inst,char *fmt, ...)
 186 {
 187     va_list ap;
 188     char lb[INITIAL_INLINEASM];
 189     unsigned char *lbp = (unsigned char *)lb;
 190
 191     if(!debug_verbose && !options.debug)
 192         return;
 193
 194     va_start(ap,fmt);
 195
 196     if (inst && *inst) {
 197         if (fmt && *fmt)
 198             sprintf(lb,"%s\t",inst);
 199         else
 200             sprintf(lb,"%s",inst);
 201         vsprintf(lb+(strlen(lb)),fmt,ap);
 202     }  else
 203         vsprintf(lb,fmt,ap);
 204
 205     while (isspace(*lbp)) lbp++;
 206
 207     if (lbp && *lbp)
 208         lineCurr = (lineCurr ?
 209         connectLine(lineCurr,newLineNode(lb)) :
 210     (lineHead = newLineNode(lb)));
 211     lineCurr->isInline = _G.inLine;
 212     lineCurr->isDebug  = _G.debugLine;
 213
 214     addpCode2pBlock(pb,newpCodeCharP(lb));
 215
 216     va_end(ap);
 217 }
 218
 219 static void Safe_vsnprintf (char *buf, size_t size, const char *fmt, va_list ap)
 220 {
 221 #if defined (HAVE_VSNPRINTF)
 222   vsnprintf (buf, size, fmt, ap);
 223 #elif defined (HAVE_VSPRINTF)
 224   vsprintf (buf, size, fmt, ap);
 225   if (strlen (buf) >= size)
 226   {
 227     fprintf (stderr, "Safe_vsnprintf: buffer (size %u) has overflown\n", size);
 228   }
 229 #elif defined (HAVE_SNPRINTF)
 230   snprintf (buf, size, "vs(n)printf required");
 231 #elif defined (HAVE_SRINTF)
 232   sprintf (buf, "vs(n)printf required");
 233   if (strlen (buf) >= size)
 234   {
 235     fprintf (stderr, "Safe_vsnprintf: buffer (size %u) has overflown\n", size);
 236   }
 237 #else
 238   assert ( !"neither vsnprintf nor vsprintf is present -- unable to proceed" );
 239 #endif
 240 }
 241
 242 void emitpComment (const char *fmt, ...)
 243 {
 244   va_list va;
 245   char buffer[4096];
 246
 247   va_start (va, fmt);
 248   if (pb) {
 249     Safe_vsnprintf (buffer, 4096, fmt, va);
 250     //fprintf (stderr, "%s\n" ,buffer);
 251     addpCode2pBlock (pb, newpCodeCharP (buffer));
 252 #if 0
 253   } else {
 254     Safe_vsnprintf (buffer, 4096, fmt, va);
 255     fprintf (stderr, "No current pBlock -- discarding comment [%s]\n", buffer);
 256 #endif
 257   }
 258   va_end (va);
 259 }
 260
 261 void emitpLabel(int key)
 262 {
 263     addpCode2pBlock(pb,newpCodeLabel(NULL,key+100+labelOffset));
 264 }
 265
 266 /* gen.h defines a macro emitpcode that should be used to call emitpcode
 267  * as this allows for easy debugging (ever asked the question: where was
 268  * this instruction geenrated? Here is the answer... */
 269 void emitpcode_real(PIC_OPCODE poc, pCodeOp *pcop)
 270 {
 271     if(pcop)
 272         addpCode2pBlock(pb,newpCode(poc,pcop));
 273     else {
 274         static int has_warned = 0;
 275
 276         DEBUGpic14_emitcode(";","%s  ignoring NULL pcop",__FUNCTION__);
 277         if (!has_warned) {
 278             has_warned = 1;
 279             fprintf( stderr, "WARNING: encountered NULL pcop--this is probably a compiler bug...\n" );
 280         }
 281     }
 282 }
 283
 284 void emitpcodeNULLop(PIC_OPCODE poc)
 285 {
 286
 287     addpCode2pBlock(pb,newpCode(poc,NULL));
 288
 289 }
 290
 291
 292 /*-----------------------------------------------------------------*/
 293 /* pic14_emitcode - writes the code into a file : for now it is simple    */
 294 /*-----------------------------------------------------------------*/
 295 void pic14_emitcode (char *inst,char *fmt, ...)
 296 {
 297     va_list ap;
 298     char lb[INITIAL_INLINEASM];
 299     char *lbp = lb;
 300
 301     va_start(ap,fmt);
 302
 303     if (inst && *inst) {
 304         if (fmt && *fmt)
 305             sprintf(lb,"%s\t",inst);
 306         else
 307             sprintf(lb,"%s",inst);
 308         vsprintf(lb+(strlen(lb)),fmt,ap);
 309     }  else
 310         vsprintf(lb,fmt,ap);
 311
 312     while (isspace(*lbp)) lbp++;
 313
 314     if (lbp && *lbp)
 315         lineCurr = (lineCurr ?
 316         connectLine(lineCurr,newLineNode(lb)) :
 317     (lineHead = newLineNode(lb)));
 318     lineCurr->isInline = _G.inLine;
 319     lineCurr->isDebug  = _G.debugLine;
 320     lineCurr->isLabel = (lbp[strlen (lbp) - 1] == ':');
 321
 322     if(debug_verbose)
 323         addpCode2pBlock(pb,newpCodeCharP(lb));
 324
 325     va_end(ap);
 326 }
 327
 328 /*-----------------------------------------------------------------*/
 329 /* pic14_emitDebuggerSymbol - associate the current code location  */
 330 /*   with a debugger symbol                                        */
 331 /*-----------------------------------------------------------------*/
 332 void
 333 pic14_emitDebuggerSymbol (char * debugSym)
 334 {
 335     _G.debugLine = 1;
 336     pic14_emitcode ("", ";%s ==.", debugSym);
 337     _G.debugLine = 0;
 338 }
 339
 340 #if 0
 341 /*-----------------------------------------------------------------*/
 342 /* getFreePtr - returns r0 or r1 whichever is free or can be pushed*/
 343 /*-----------------------------------------------------------------*/
 344 static regs *getFreePtr (iCode *ic, asmop **aopp, bool result)
 345 {
 346     bool r0iu = FALSE , r1iu = FALSE;
 347     bool r0ou = FALSE , r1ou = FALSE;
 348
 349     /* the logic: if r0 & r1 used in the instruction
 350     then we are in trouble otherwise */
 351
 352     /* first check if r0 & r1 are used by this
 353     instruction, in which case we are in trouble */
 354     if ((r0iu = bitVectBitValue(ic->rUsed,R0_IDX)) &&
 355         (r1iu = bitVectBitValue(ic->rUsed,R1_IDX)))
 356     {
 357         goto endOfWorld;
 358     }
 359
 360     r0ou = bitVectBitValue(ic->rMask,R0_IDX);
 361     r1ou = bitVectBitValue(ic->rMask,R1_IDX);
 362
 363     /* if no usage of r0 then return it */
 364     if (!r0iu && !r0ou) {
 365         ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
 366         (*aopp)->type = AOP_R0;
 367
 368         return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
 369     }
 370
 371     /* if no usage of r1 then return it */
 372     if (!r1iu && !r1ou) {
 373         ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
 374         (*aopp)->type = AOP_R1;
 375
 376         return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R1_IDX);
 377     }
 378
 379     /* now we know they both have usage */
 380     /* if r0 not used in this instruction */
 381     if (!r0iu) {
 382         /* push it if not already pushed */
 383         if (!_G.r0Pushed) {
 384             //pic14_emitcode ("push","%s",
 385             //        pic14_regWithIdx(R0_IDX)->dname);
 386             _G.r0Pushed++ ;
 387         }
 388
 389         ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
 390         (*aopp)->type = AOP_R0;
 391
 392         return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
 393     }
 394
 395     /* if r1 not used then */
 396
 397     if (!r1iu) {
 398         /* push it if not already pushed */
 399         if (!_G.r1Pushed) {
 400             //pic14_emitcode ("push","%s",
 401             //        pic14_regWithIdx(R1_IDX)->dname);
 402             _G.r1Pushed++ ;
 403         }
 404
 405         ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
 406         (*aopp)->type = AOP_R1;
 407         return pic14_regWithIdx(R1_IDX);
 408     }
 409
 410 endOfWorld :
 411     /* I said end of world but not quite end of world yet */
 412     /* if this is a result then we can push it on the stack*/
 413     if (result) {
 414         (*aopp)->type = AOP_STK;
 415         return NULL;
 416     }
 417
 418     /* other wise this is true end of the world */
 419     werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
 420         "getFreePtr should never reach here");
 421     exit(0);
 422 }
 423 #endif
 424
 425 /*-----------------------------------------------------------------*/
 426 /* newAsmop - creates a new asmOp                                  */
 427 /*-----------------------------------------------------------------*/
 428 asmop *newAsmop (short type)
 429 {
 430     asmop *aop;
 431
 432     aop = Safe_calloc(1,sizeof(asmop));
 433     aop->type = type;
 434     return aop;
 435 }
 436
 437 static void genSetDPTR(int n)
 438 {
 439     if (!n)
 440     {
 441         pic14_emitcode(";", "Select standard DPTR");
 442         pic14_emitcode("mov", "dps, #0x00");
 443     }
 444     else
 445     {
 446         pic14_emitcode(";", "Select alternate DPTR");
 447         pic14_emitcode("mov", "dps, #0x01");
 448     }
 449 }
 450
 451 /*-----------------------------------------------------------------*/
 452 /* resolveIfx - converts an iCode ifx into a form more useful for  */
 453 /*              generating code                                    */
 454 /*-----------------------------------------------------------------*/
 455 static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
 456 {
 457     if(!resIfx)
 458         return;
 459
 460     //  DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
 461
 462     resIfx->condition = 1;  /* assume that the ifx is true */
 463     resIfx->generated = 0;  /* indicate that the ifx has not been used */
 464
 465     if(!ifx) {
 466         resIfx->lbl = NULL; /* this is wrong: newiTempLabel(NULL);  / * oops, there is no ifx. so create a label */
 467                                             /*
 468                                             DEBUGpic14_emitcode("; ***","%s %d null ifx creating new label key =%d",
 469                                             __FUNCTION__,__LINE__,resIfx->lbl->key);
 470         */
 471     } else {
 472         if(IC_TRUE(ifx)) {
 473             resIfx->lbl = IC_TRUE(ifx);
 474         } else {
 475             resIfx->lbl = IC_FALSE(ifx);
 476             resIfx->condition = 0;
 477         }
 478         /*
 479         if(IC_TRUE(ifx))
 480         DEBUGpic14_emitcode("; ***","ifx true is non-null");
 481         if(IC_FALSE(ifx))
 482         DEBUGpic14_emitcode("; ***","ifx false is non-null");
 483         */
 484     }
 485
 486     //  DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
 487
 488 }
 489 /*-----------------------------------------------------------------*/
 490 /* pointerCode - returns the code for a pointer type               */
 491 /*-----------------------------------------------------------------*/
 492 #if 0
 493 static int pointerCode (sym_link *etype)
 494 {
 495
 496     return PTR_TYPE(SPEC_OCLS(etype));
 497
 498 }
 499 #endif
 500
 501 /*-----------------------------------------------------------------*/
 502 /* aopForSym - for a true symbol                                   */
 503 /*-----------------------------------------------------------------*/
 504 static asmop *aopForSym (iCode *ic,symbol *sym,bool result)
 505 {
 506     asmop *aop;
 507     memmap *space= SPEC_OCLS(sym->etype);
 508
 509     DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
 510     /* if already has one */
 511     if (sym->aop)
 512         return sym->aop;
 513
 514     //DEBUGpic14_emitcode(";","%d",__LINE__);
 515     /* if it is in direct space */
 516     if (IN_DIRSPACE(space)) {
 517         sym->aop = aop = newAsmop (AOP_DIR);
 518         aop->aopu.aop_dir = sym->rname ;
 519         aop->size = getSize(sym->type);
 520         DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
 521         return aop;
 522     }
 523
 524     /* special case for a function */
 525     if (IS_FUNC(sym->type)) {
 526
 527         sym->aop = aop = newAsmop(AOP_PCODE);
 528         aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
 529         PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
 530         PCOI(aop->aopu.pcop)->_function = 1;
 531         PCOI(aop->aopu.pcop)->index = 0;
 532         aop->size = FPTRSIZE;
 533         /*
 534         sym->aop = aop = newAsmop(AOP_IMMD);
 535         aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
 536         strcpy(aop->aopu.aop_immd,sym->rname);
 537         aop->size = FPTRSIZE;
 538         */
 539         DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
 540         return aop;
 541     }
 542
 543     if (IS_ARRAY(sym->type)) {
 544         sym->aop = aop = newAsmop(AOP_PCODE);
 545         aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
 546         PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
 547         PCOI(aop->aopu.pcop)->_function = 0;
 548         PCOI(aop->aopu.pcop)->index = 0;
 549         aop->size = getSize(sym->etype) * DCL_ELEM(sym->type);
 550
 551         DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
 552         return aop;
 553     }
 554
 555     /* only remaining is far space */
 556     /* in which case DPTR gets the address */
 557     sym->aop = aop = newAsmop(AOP_PCODE);
 558
 559     aop->aopu.pcop = popGetImmd(sym->rname,0,0,0);
 560     PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
 561     PCOI(aop->aopu.pcop)->index = 0;
 562
 563     DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
 564         __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
 565
 566     allocDirReg (IC_LEFT(ic));
 567
 568     aop->size = FPTRSIZE;
 569     /*
 570     DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
 571     sym->aop = aop = newAsmop(AOP_DPTR);
 572     pic14_emitcode ("mov","dptr,#%s", sym->rname);
 573     aop->size = getSize(sym->type);
 574
 575       DEBUGpic14_emitcode(";","%d size = %d",__LINE__,aop->size);
 576     */
 577
 578     /* if it is in code space */
 579     if (IN_CODESPACE(space))
 580         aop->code = 1;
 581
 582     return aop;
 583 }
 584
 585 /*-----------------------------------------------------------------*/
 586 /* aopForRemat - rematerialzes an object                           */
 587 /*-----------------------------------------------------------------*/
 588 static asmop *aopForRemat (operand *op) // x symbol *sym)
 589 {
 590     symbol *sym = OP_SYMBOL(op);
 591     iCode *ic = NULL;
 592     asmop *aop = newAsmop(AOP_PCODE);
 593     int val = 0;
 594     int offset = 0;
 595
 596     ic = sym->rematiCode;
 597
 598     DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
 599     if(IS_OP_POINTER(op)) {
 600         DEBUGpic14_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
 601     }
 602     for (;;) {
 603         if (ic->op == '+') {
 604             val += (int) operandLitValue(IC_RIGHT(ic));
 605         } else if (ic->op == '-') {
 606             val -= (int) operandLitValue(IC_RIGHT(ic));
 607         } else
 608             break;
 609
 610         ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
 611     }
 612
 613     offset = OP_SYMBOL(IC_LEFT(ic))->offset;
 614     aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val,0);
 615     PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
 616     PCOI(aop->aopu.pcop)->index = val;
 617
 618     DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
 619         __LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
 620         val, IS_PTR_CONST(operandType(op)));
 621
 622     //  DEBUGpic14_emitcode(";","aop type  %s",AopType(AOP_TYPE(IC_LEFT(ic))));
 623
 624     allocDirReg (IC_LEFT(ic));
 625
 626     return aop;
 627 }
 628
 629 int aopIdx (asmop *aop, int offset)
 630 {
 631     if(!aop)
 632         return -1;
 633
 634     if(aop->type !=  AOP_REG)
 635         return -2;
 636
 637     return aop->aopu.aop_reg[offset]->rIdx;
 638
 639 }
 640 /*-----------------------------------------------------------------*/
 641 /* regsInCommon - two operands have some registers in common       */
 642 /*-----------------------------------------------------------------*/
 643 static bool regsInCommon (operand *op1, operand *op2)
 644 {
 645     symbol *sym1, *sym2;
 646     int i;
 647
 648     /* if they have registers in common */
 649     if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
 650         return FALSE ;
 651
 652     sym1 = OP_SYMBOL(op1);
 653     sym2 = OP_SYMBOL(op2);
 654
 655     if (sym1->nRegs == 0 || sym2->nRegs == 0)
 656         return FALSE ;
 657
 658     for (i = 0 ; i < sym1->nRegs ; i++) {
 659         int j;
 660         if (!sym1->regs[i])
 661             continue ;
 662
 663         for (j = 0 ; j < sym2->nRegs ;j++ ) {
 664             if (!sym2->regs[j])
 665                 continue ;
 666
 667             if (sym2->regs[j] == sym1->regs[i])
 668                 return TRUE ;
 669         }
 670     }
 671
 672     return FALSE ;
 673 }
 674
 675 /*-----------------------------------------------------------------*/
 676 /* operandsEqu - equivalent                                        */
 677 /*-----------------------------------------------------------------*/
 678 static bool operandsEqu ( operand *op1, operand *op2)
 679 {
 680     symbol *sym1, *sym2;
 681
 682     /* if they not symbols */
 683     if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
 684         return FALSE;
 685
 686     sym1 = OP_SYMBOL(op1);
 687     sym2 = OP_SYMBOL(op2);
 688
 689     /* if both are itemps & one is spilt
 690     and the other is not then false */
 691     if (IS_ITEMP(op1) && IS_ITEMP(op2) &&
 692         sym1->isspilt != sym2->isspilt )
 693         return FALSE ;
 694
 695     /* if they are the same */
 696     if (sym1 == sym2)
 697         return TRUE ;
 698
 699     if (sym1->rname[0] && sym2->rname[0]
 700         && strcmp (sym1->rname, sym2->rname) == 0)
 701         return TRUE;
 702
 703
 704     /* if left is a tmp & right is not */
 705     if (IS_ITEMP(op1)  &&
 706         !IS_ITEMP(op2) &&
 707         sym1->isspilt  &&
 708         (sym1->usl.spillLoc == sym2))
 709         return TRUE;
 710
 711     if (IS_ITEMP(op2)  &&
 712         !IS_ITEMP(op1) &&
 713         sym2->isspilt  &&
 714         sym1->level > 0 &&
 715         (sym2->usl.spillLoc == sym1))
 716         return TRUE ;
 717
 718     return FALSE ;
 719 }
 720
 721 /*-----------------------------------------------------------------*/
 722 /* pic14_sameRegs - two asmops have the same registers             */
 723 /*-----------------------------------------------------------------*/
 724 bool pic14_sameRegs (asmop *aop1, asmop *aop2 )
 725 {
 726     int i;
 727
 728     if (aop1 == aop2)
 729         return TRUE ;
 730
 731     if (aop1->type != AOP_REG ||
 732         aop2->type != AOP_REG )
 733         return FALSE ;
 734
 735     if (aop1->size != aop2->size )
 736         return FALSE ;
 737
 738     for (i = 0 ; i < aop1->size ; i++ )
 739         if (aop1->aopu.aop_reg[i] !=
 740             aop2->aopu.aop_reg[i] )
 741             return FALSE ;
 742
 743         return TRUE ;
 744 }
 745
 746 /*-----------------------------------------------------------------*/
 747 /* aopOp - allocates an asmop for an operand  :                    */
 748 /*-----------------------------------------------------------------*/
 749 void aopOp (operand *op, iCode *ic, bool result)
 750 {
 751     asmop *aop;
 752     symbol *sym;
 753     int i;
 754
 755     if (!op)
 756         return ;
 757
 758     /* if this a literal */
 759     if (IS_OP_LITERAL(op)) {
 760         op->aop = aop = newAsmop(AOP_LIT);
 761         aop->aopu.aop_lit = op->operand.valOperand;
 762         aop->size = getSize(operandType(op));
 763         return;
 764     }
 765
 766     {
 767         sym_link *type = operandType(op);
 768         if(IS_PTR_CONST(type))
 769             DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
 770     }
 771
 772     /* if already has a asmop then continue */
 773     if (op->aop)
 774         return ;
 775
 776     /* if the underlying symbol has a aop */
 777     if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
 778         DEBUGpic14_emitcode(";","%d",__LINE__);
 779         op->aop = OP_SYMBOL(op)->aop;
 780         return;
 781     }
 782
 783     /* if this is a true symbol */
 784     if (IS_TRUE_SYMOP(op)) {
 785         //DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
 786         op->aop = aopForSym(ic,OP_SYMBOL(op),result);
 787         return ;
 788     }
 789
 790     /* this is a temporary : this has
 791     only four choices :
 792     a) register
 793     b) spillocation
 794     c) rematerialize
 795     d) conditional
 796     e) can be a return use only */
 797
 798     sym = OP_SYMBOL(op);
 799
 800
 801     /* if the type is a conditional */
 802     if (sym->regType == REG_CND) {
 803         aop = op->aop = sym->aop = newAsmop(AOP_CRY);
 804         aop->size = 0;
 805         return;
 806     }
 807
 808     /* if it is spilt then two situations
 809     a) is rematerialize
 810     b) has a spill location */
 811     if (sym->isspilt || sym->nRegs == 0) {
 812
 813         DEBUGpic14_emitcode(";","%d",__LINE__);
 814         /* rematerialize it NOW */
 815         if (sym->remat) {
 816
 817             sym->aop = op->aop = aop = aopForRemat (op);
 818             aop->size = getSize(sym->type);
 819             //DEBUGpic14_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
 820             return;
 821         }
 822
 823 #if 0
 824         /* WREG is not usable as an ordinary operand with PIC architecture,
 825          * one might introduce a scratch register that can be used to make
 826          * WREG accesible as an operand... disable WREG for now */
 827         if (sym->accuse) {
 828             int i;
 829             aop = op->aop = sym->aop = newAsmop(AOP_ACC);
 830             aop->size = getSize(sym->type);
 831             for ( i = 0 ; i < 2 ; i++ )
 832                 aop->aopu.aop_str[i] = accUse[i];
 833             DEBUGpic14_emitcode(";","%d size=%d",__LINE__,aop->size);
 834             return;
 835         }
 836 #endif
 837
 838         if (sym->ruonly ) {
 839             if(sym->isptr) {    // && sym->uptr
 840                 aop = op->aop = sym->aop = newAsmop(AOP_PCODE);
 841                 aop->aopu.pcop = newpCodeOp(NULL,PO_GPR_POINTER); //popCopyReg(&pc_fsr);
 842
 843                 //PCOI(aop->aopu.pcop)->_const = 0;
 844                 //PCOI(aop->aopu.pcop)->index = 0;
 845                 /*
 846                 DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
 847                 __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
 848                 */
 849                 //allocDirReg (IC_LEFT(ic));
 850
 851                 aop->size = getSize(sym->type);
 852                 DEBUGpic14_emitcode(";","%d",__LINE__);
 853                 return;
 854
 855             } else {
 856
 857                 unsigned i;
 858
 859                 aop = op->aop = sym->aop = newAsmop(AOP_STR);
 860                 aop->size = getSize(sym->type);
 861                 for ( i = 0 ; i < fReturnSizePic ; i++ )
 862                     aop->aopu.aop_str[i] = fReturn[i];
 863
 864                 DEBUGpic14_emitcode(";","%d",__LINE__);
 865                 return;
 866             }
 867         }
 868
 869         /* else spill location  */
 870         if (sym->usl.spillLoc)
 871         {
 872             asmop *oldAsmOp = NULL;
 873
 874             if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
 875             {
 876                 /* force a new aop if sizes differ */
 877                 oldAsmOp = sym->usl.spillLoc->aop;
 878                 sym->usl.spillLoc->aop = NULL;
 879             }
 880             DEBUGpic14_emitcode(";","%s %d %s sym->rname = %s, offset %d",
 881                 __FUNCTION__,__LINE__,
 882                 sym->usl.spillLoc->rname,
 883                 sym->rname, sym->usl.spillLoc->offset);
 884
 885             sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
 886             if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
 887             {
 888                 /* Don't reuse the new aop, go with the last one */
 889                 sym->usl.spillLoc->aop = oldAsmOp;
 890             }
 891             //aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
 892             aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
 893                 getSize(sym->type),
 894                 sym->usl.spillLoc->offset);
 895             aop->size = getSize(sym->type);
 896
 897             return;
 898         }
 899     }
 900
 901     {
 902         sym_link *type = operandType(op);
 903         if(IS_PTR_CONST(type))
 904             DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
 905     }
 906
 907     /* must be in a register */
 908     DEBUGpic14_emitcode(";","%d register type nRegs=%d",__LINE__,sym->nRegs);
 909     sym->aop = op->aop = aop = newAsmop(AOP_REG);
 910     aop->size = sym->nRegs;
 911     for ( i = 0 ; i < sym->nRegs ;i++)
 912         aop->aopu.aop_reg[i] = sym->regs[i];
 913 }
 914
 915 /*-----------------------------------------------------------------*/
 916 /* freeAsmop - free up the asmop given to an operand               */
 917 /*----------------------------------------------------------------*/
 918 void freeAsmop (operand *op, asmop *aaop, iCode *ic, bool pop)
 919 {
 920     asmop *aop ;
 921
 922     if (!op)
 923         aop = aaop;
 924     else
 925         aop = op->aop;
 926
 927     if (!aop)
 928         return ;
 929
 930     if (aop->freed)
 931         goto dealloc;
 932
 933     aop->freed = 1;
 934
 935     /* depending on the asmop type only three cases need work AOP_RO
 936     , AOP_R1 && AOP_STK */
 937 #if 0
 938     switch (aop->type) {
 939     case AOP_R0 :
 940         if (_G.r0Pushed ) {
 941             if (pop) {
 942                 pic14_emitcode ("pop","ar0");
 943                 _G.r0Pushed--;
 944             }
 945         }
 946         bitVectUnSetBit(ic->rUsed,R0_IDX);
 947         break;
 948
 949     case AOP_R1 :
 950         if (_G.r1Pushed ) {
 951             if (pop) {
 952                 pic14_emitcode ("pop","ar1");
 953                 _G.r1Pushed--;
 954             }
 955         }
 956         bitVectUnSetBit(ic->rUsed,R1_IDX);
 957         break;
 958
 959     case AOP_STK :
 960         {
 961             int sz = aop->size;
 962             int stk = aop->aopu.aop_stk + aop->size;
 963             bitVectUnSetBit(ic->rUsed,R0_IDX);
 964             bitVectUnSetBit(ic->rUsed,R1_IDX);
 965
 966             getFreePtr(ic,&aop,FALSE);
 967
 968             if (options.stack10bit)
 969             {
 970                 /* I'm not sure what to do here yet... */
 971                 /* #STUB */
 972                 fprintf(stderr,
 973                     "*** Warning: probably generating bad code for "
 974                     "10 bit stack mode.\n");
 975             }
 976
 977             if (stk) {
 978                 pic14_emitcode ("mov","a,_bp");
 979                 pic14_emitcode ("add","a,#0x%02x",((char)stk) & 0xff);
 980                 pic14_emitcode ("mov","%s,a",aop->aopu.aop_ptr->name);
 981             } else {
 982                 pic14_emitcode ("mov","%s,_bp",aop->aopu.aop_ptr->name);
 983             }
 984
 985             while (sz--) {
 986                 pic14_emitcode("pop","acc");
 987                 pic14_emitcode("mov","@%s,a",aop->aopu.aop_ptr->name);
 988                 if (!sz) break;
 989                 pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
 990             }
 991             op->aop = aop;
 992             freeAsmop(op,NULL,ic,TRUE);
 993             if (_G.r0Pushed) {
 994                 pic14_emitcode("pop","ar0");
 995                 _G.r0Pushed--;
 996             }
 997
 998             if (_G.r1Pushed) {
 999                 pic14_emitcode("pop","ar1");
1000                 _G.r1Pushed--;
1001             }
1002         }
1003     }
1004 #endif
1005
1006 dealloc:
1007     /* all other cases just dealloc */
1008     if (op ) {
1009         op->aop = NULL;
1010         if (IS_SYMOP(op)) {
1011             OP_SYMBOL(op)->aop = NULL;
1012             /* if the symbol has a spill */
1013             if (SPIL_LOC(op))
1014                 SPIL_LOC(op)->aop = NULL;
1015         }
1016     }
1017 }
1018
1019 /*-----------------------------------------------------------------*/
1020 /* aopGet - for fetching value of the aop                          */
1021 /*-----------------------------------------------------------------*/
1022 char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
1023 {
1024     char *s = buffer ;
1025     char *rs;
1026
1027     //DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1028     /* offset is greater than
1029     size then zero */
1030     assert(aop);
1031     if (offset > (aop->size - 1) &&
1032         aop->type != AOP_LIT)
1033         return zero;
1034
1035     /* depending on type */
1036     switch (aop->type) {
1037
1038     case AOP_R0:
1039     case AOP_R1:
1040         DEBUGpic14_emitcode(";","%d",__LINE__);
1041         /* if we need to increment it */
1042         while (offset > aop->coff) {
1043             pic14_emitcode ("inc","%s",aop->aopu.aop_ptr->name);
1044             aop->coff++;
1045         }
1046
1047         while (offset < aop->coff) {
1048             pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
1049             aop->coff--;
1050         }
1051
1052         aop->coff = offset ;
1053         if (aop->paged) {
1054             pic14_emitcode("movx","a,@%s",aop->aopu.aop_ptr->name);
1055             return (dname ? "acc" : "a");
1056         }
1057         sprintf(s,"@%s",aop->aopu.aop_ptr->name);
1058         rs = Safe_calloc(1,strlen(s)+1);
1059         strcpy(rs,s);
1060         return rs;
1061
1062     case AOP_DPTR:
1063     case AOP_DPTR2:
1064         DEBUGpic14_emitcode(";","%d",__LINE__);
1065         if (aop->type == AOP_DPTR2)
1066         {
1067             genSetDPTR(1);
1068         }
1069
1070         while (offset > aop->coff) {
1071             pic14_emitcode ("inc","dptr");
1072             aop->coff++;
1073         }
1074
1075         while (offset < aop->coff) {
1076             pic14_emitcode("lcall","__decdptr");
1077             aop->coff--;
1078         }
1079
1080         aop->coff = offset;
1081         if (aop->code) {
1082             pic14_emitcode("clr","a");
1083             pic14_emitcode("movc","a,@a+dptr");
1084         }
1085         else {
1086             pic14_emitcode("movx","a,@dptr");
1087         }
1088
1089         if (aop->type == AOP_DPTR2)
1090         {
1091             genSetDPTR(0);
1092         }
1093
1094         return (dname ? "acc" : "a");
1095
1096
1097     case AOP_IMMD:
1098         if (bit16)
1099             sprintf (s,"%s",aop->aopu.aop_immd);
1100         else
1101             if (offset)
1102                 sprintf(s,"(%s >> %d)",
1103                 aop->aopu.aop_immd,
1104                 offset*8);
1105             else
1106                 sprintf(s,"%s",
1107                 aop->aopu.aop_immd);
1108             DEBUGpic14_emitcode(";","%d immd %s",__LINE__,s);
1109             rs = Safe_calloc(1,strlen(s)+1);
1110             strcpy(rs,s);
1111             return rs;
1112
1113     case AOP_DIR:
1114         if (offset) {
1115             sprintf(s,"(%s + %d)",
1116                 aop->aopu.aop_dir,
1117                 offset);
1118             DEBUGpic14_emitcode(";","oops AOP_DIR did this %s\n",s);
1119         } else
1120             sprintf(s,"%s",aop->aopu.aop_dir);
1121         rs = Safe_calloc(1,strlen(s)+1);
1122         strcpy(rs,s);
1123         return rs;
1124
1125     case AOP_REG:
1126         //if (dname)
1127         //    return aop->aopu.aop_reg[offset]->dname;
1128         //else
1129         return aop->aopu.aop_reg[offset]->name;
1130
1131     case AOP_CRY:
1132         //pic14_emitcode(";","%d",__LINE__);
1133         return aop->aopu.aop_dir;
1134
1135     case AOP_ACC:
1136         DEBUGpic14_emitcode(";Warning -pic port ignoring get(AOP_ACC)","%d",__LINE__);
1137         return "AOP_accumulator_bug";
1138
1139     case AOP_LIT:
1140         sprintf(s, "0x%02x", pic14aopLiteral (aop->aopu.aop_lit, offset));
1141         rs = Safe_strdup(s);
1142         return rs;
1143
1144     case AOP_STR:
1145         aop->coff = offset ;
1146         if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
1147             dname)
1148             return "acc";
1149         DEBUGpic14_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
1150
1151         return aop->aopu.aop_str[offset];
1152
1153     case AOP_PCODE:
1154         {
1155             pCodeOp *pcop = aop->aopu.pcop;
1156             DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
1157             if(pcop->name) {
1158                 if (pcop->type == PO_IMMEDIATE) {
1159                     offset += PCOI(pcop)->index;
1160                 }
1161                 if (offset) {
1162                     DEBUGpic14_emitcode(";","%s offset %d",pcop->name,offset);
1163                     sprintf(s,"(%s+%d)", pcop->name,offset);
1164                 } else {
1165                     DEBUGpic14_emitcode(";","%s",pcop->name);
1166                     sprintf(s,"%s", pcop->name);
1167                 }
1168             } else
1169                 sprintf(s,"0x%02x", PCOI(aop->aopu.pcop)->offset);
1170
1171         }
1172         rs = Safe_calloc(1,strlen(s)+1);
1173         strcpy(rs,s);
1174         return rs;
1175
1176   }
1177
1178   werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1179       "aopget got unsupported aop->type");
1180   exit(0);
1181 }
1182
1183
1184 /*-----------------------------------------------------------------*/
1185 /* popGetTempReg - create a new temporary pCodeOp                  */
1186 /*-----------------------------------------------------------------*/
1187 pCodeOp *popGetTempReg(void)
1188 {
1189
1190     pCodeOp *pcop;
1191
1192     pcop = newpCodeOp(NULL, PO_GPR_TEMP);
1193     if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
1194         PCOR(pcop)->r->wasUsed=1;
1195         PCOR(pcop)->r->isFree=0;
1196     }
1197
1198     return pcop;
1199 }
1200
1201 /*-----------------------------------------------------------------*/
1202 /* popReleaseTempReg - create a new temporary pCodeOp                  */
1203 /*-----------------------------------------------------------------*/
1204 void popReleaseTempReg(pCodeOp *pcop)
1205 {
1206
1207     if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r)
1208         PCOR(pcop)->r->isFree = 1;
1209
1210 }
1211 /*-----------------------------------------------------------------*/
1212 /* popGetLabel - create a new pCodeOp of type PO_LABEL             */
1213 /*-----------------------------------------------------------------*/
1214 pCodeOp *popGetLabel(unsigned int key)
1215 {
1216
1217     DEBUGpic14_emitcode ("; ***","%s  key=%d, label offset %d",__FUNCTION__,key, labelOffset);
1218
1219     if(key>(unsigned int)max_key)
1220         max_key = key;
1221
1222     return newpCodeOpLabel(NULL,key+100+labelOffset);
1223 }
1224
1225 /*-------------------------------------------------------------------*/
1226 /* popGetHighLabel - create a new pCodeOp of type PO_LABEL with offset=1 */
1227 /*-------------------------------------------------------------------*/
1228 pCodeOp *popGetHighLabel(unsigned int key)
1229 {
1230     pCodeOp *pcop;
1231     pcop = popGetLabel(key);
1232     PCOLAB(pcop)->offset = 1;
1233     return pcop;
1234 }
1235
1236 /*-----------------------------------------------------------------*/
1237 /* popGetLit - asm operator to pcode operator conversion               */
1238 /*-----------------------------------------------------------------*/
1239 pCodeOp *popGetLit(unsigned int lit)
1240 {
1241
1242     return newpCodeOpLit((unsigned char)lit);
1243 }
1244
1245 /*-----------------------------------------------------------------*/
1246 /* popGetImmd - asm operator to pcode immediate conversion         */
1247 /*-----------------------------------------------------------------*/
1248 pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func)
1249 {
1250
1251     return newpCodeOpImmd(name, offset,index, 0, is_func);
1252 }
1253
1254 extern set *externs;
1255
1256 /*-----------------------------------------------------------------*/
1257 /* popGetWithString - asm operator to pcode operator conversion            */
1258 /*-----------------------------------------------------------------*/
1259 pCodeOp *popGetWithString(char *str, int isExtern)
1260 {
1261     pCodeOp *pcop;
1262
1263
1264     if(!str) {
1265         fprintf(stderr,"NULL string %s %d\n",__FILE__,__LINE__);
1266         exit (1);
1267     }
1268
1269     pcop = newpCodeOp(str,PO_STR);
1270     PCOS(pcop)->isPublic = isExtern ? 1 : 0;
1271
1272     return pcop;
1273 }
1274
1275 pCodeOp *popGetExternal (char *str, int isReg)
1276 {
1277     pCodeOp *pcop;
1278
1279     if (isReg) {
1280         pcop = newpCodeOpRegFromStr(str);
1281     } else {
1282         pcop = popGetWithString (str, 1);
1283     }
1284
1285     if (str) {
1286       symbol *sym;
1287
1288       for (sym = setFirstItem (externs); sym; sym = setNextItem (externs))
1289       {
1290         if (!strcmp (str, sym->rname)) break;
1291       }
1292
1293       if (!sym)
1294       {
1295         sym = newSymbol(str, 0);
1296         strncpy(sym->rname, str, SDCC_NAME_MAX);
1297         addSet (&externs, sym);
1298       } // if
1299       sym->used++;
1300     }
1301     return pcop;
1302 }
1303
1304 /*-----------------------------------------------------------------*/
1305 /* popRegFromString -                                              */
1306 /*-----------------------------------------------------------------*/
1307 pCodeOp *popRegFromString(char *str, int size, int offset)
1308 {
1309
1310     pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
1311     pcop->type = PO_DIR;
1312
1313     DEBUGpic14_emitcode(";","%d",__LINE__);
1314
1315     if(!str)
1316         str = "BAD_STRING";
1317
1318     pcop->name = Safe_calloc(1,strlen(str)+1);
1319     strcpy(pcop->name,str);
1320
1321     //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
1322
1323     PCOR(pcop)->r = dirregWithName(pcop->name);
1324     if(PCOR(pcop)->r == NULL) {
1325         //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
1326         PCOR(pcop)->r = allocRegByName (pcop->name,size);
1327         DEBUGpic14_emitcode(";","%d  %s   offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
1328     } else {
1329         DEBUGpic14_emitcode(";","%d  %s   offset=%d",__LINE__,pcop->name,offset);
1330     }
1331     PCOR(pcop)->instance = offset;
1332
1333     return pcop;
1334 }
1335
1336 /*-----------------------------------------------------------------*/
1337 /*-----------------------------------------------------------------*/
1338 pCodeOp *popRegFromIdx(int rIdx)
1339 {
1340     pCodeOp *pcop;
1341
1342     DEBUGpic14_emitcode ("; ***","%s,%d  , rIdx=0x%x",
1343         __FUNCTION__,__LINE__,rIdx);
1344
1345     pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
1346
1347     PCOR(pcop)->rIdx = rIdx;
1348     PCOR(pcop)->r = typeRegWithIdx(rIdx,REG_STK,1);
1349     PCOR(pcop)->r->isFree = 0;
1350     PCOR(pcop)->r->wasUsed = 1;
1351
1352     pcop->type = PCOR(pcop)->r->pc_type;
1353
1354
1355     return pcop;
1356 }
1357
1358 /*-----------------------------------------------------------------*/
1359 /* popGet - asm operator to pcode operator conversion              */
1360 /*-----------------------------------------------------------------*/
1361 pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
1362 {
1363     //char *s = buffer ;
1364     //char *rs;
1365
1366     pCodeOp *pcop;
1367
1368     //DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1369     /* offset is greater than
1370     size then zero */
1371
1372     assert (aop);
1373
1374
1375     /* XXX: still needed for BIT operands (AOP_CRY) */
1376     if (offset > (aop->size - 1) &&
1377         aop->type != AOP_LIT &&
1378         aop->type != AOP_PCODE)
1379     {
1380         printf( "%s: (offset[%d] > AOP_SIZE(op)[%d]-1) && AOP_TYPE(op) != AOP_LIT)\n", __FUNCTION__, offset, aop->size);
1381         return NULL;  //zero;
1382     }
1383
1384     /* depending on type */
1385     switch (aop->type) {
1386
1387     case AOP_R0:
1388     case AOP_R1:
1389     case AOP_DPTR:
1390     case AOP_DPTR2:
1391     case AOP_ACC:
1392         DEBUGpic14_emitcode(";8051 legacy","%d type = %s",__LINE__,AopType(aop->type));
1393         return NULL;
1394
1395     case AOP_IMMD:
1396         DEBUGpic14_emitcode(";","%d",__LINE__);
1397         return popGetImmd(aop->aopu.aop_immd,offset,0,0);
1398
1399     case AOP_DIR:
1400         return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
1401 #if 0
1402         pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
1403         pcop->type = PO_DIR;
1404
1405         pcop->name = Safe_calloc(1,strlen(aop->aopu.aop_dir)+1);
1406         strcpy(pcop->name,aop->aopu.aop_dir);
1407         PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
1408         if(PCOR(pcop)->r == NULL) {
1409             //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
1410             PCOR(pcop)->r = allocRegByName (aop->aopu.aop_dir,aop->size);
1411             DEBUGpic14_emitcode(";","%d  %s   offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
1412         } else {
1413             DEBUGpic14_emitcode(";","%d  %s   offset=%d",__LINE__,pcop->name,offset);
1414         }
1415         PCOR(pcop)->instance = offset;
1416
1417         return pcop;
1418 #endif
1419
1420     case AOP_REG:
1421         {
1422             int rIdx;
1423             assert (offset < aop->size);
1424             rIdx = aop->aopu.aop_reg[offset]->rIdx;
1425
1426             pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
1427             PCOR(pcop)->rIdx = rIdx;
1428             PCOR(pcop)->r = pic14_regWithIdx(rIdx);
1429             PCOR(pcop)->r->wasUsed=1;
1430             PCOR(pcop)->r->isFree=0;
1431
1432             PCOR(pcop)->instance = offset;
1433             pcop->type = PCOR(pcop)->r->pc_type;
1434             //rs = aop->aopu.aop_reg[offset]->name;
1435             DEBUGpic14_emitcode(";","%d rIdx = r0x%X ",__LINE__,rIdx);
1436             return pcop;
1437         }
1438
1439     case AOP_CRY:
1440         pcop = newpCodeOpBit(aop->aopu.aop_dir,-1,1);
1441         PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
1442         //if(PCOR(pcop)->r == NULL)
1443         //fprintf(stderr,"%d - couldn't find %s in allocated registers\n",__LINE__,aop->aopu.aop_dir);
1444         return pcop;
1445
1446     case AOP_LIT:
1447         return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
1448
1449     case AOP_STR:
1450         DEBUGpic14_emitcode(";","%d  %s",__LINE__,aop->aopu.aop_str[offset]);
1451         return newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
1452         /*
1453         pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
1454         PCOR(pcop)->r = allocRegByName(aop->aopu.aop_str[offset]);
1455         PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
1456         pcop->type = PCOR(pcop)->r->pc_type;
1457         pcop->name = PCOR(pcop)->r->name;
1458
1459           return pcop;
1460         */
1461
1462     case AOP_PCODE:
1463         pcop = NULL;
1464         DEBUGpic14_emitcode(";","popGet AOP_PCODE (%s + %i) %d %s",pCodeOpType(aop->aopu.pcop), offset,
1465             __LINE__,
1466             ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"));
1467         //emitpComment ("popGet; name %s, offset: %i, pcop-type: %s\n", aop->aopu.pcop->name, offset, pCodeOpType (aop->aopu.pcop));
1468         switch (aop->aopu.pcop->type)
1469         {
1470         case PO_IMMEDIATE:
1471           pcop = pCodeOpCopy (aop->aopu.pcop);
1472           /* usually we want to access the memory at "<symbol> + offset" (using ->index),
1473            * but sometimes we want to access the high byte of the symbol's address (using ->offset) */
1474           PCOI(pcop)->index += offset;
1475           //PCOI(pcop)->offset = 0;
1476           break;
1477         case PO_DIR:
1478           pcop = pCodeOpCopy (aop->aopu.pcop);
1479           PCOR(pcop)->instance = offset;
1480           break;
1481         default:
1482           assert ( !"unhandled pCode type" );
1483           break;
1484         } // switch
1485         return pcop;
1486     }
1487
1488     werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1489         "popGet got unsupported aop->type");
1490     exit(0);
1491 }
1492
1493 /*-----------------------------------------------------------------*/
1494 /* popGetAddr - access the low/high word of a symbol (immediate)   */
1495 /*              (for non-PO_IMMEDIATEs this is the same as popGet) */
1496 /*-----------------------------------------------------------------*/
1497 pCodeOp *popGetAddr (asmop *aop, int offset, int index)
1498 {
1499   if (aop->type == AOP_PCODE && aop->aopu.pcop->type == PO_IMMEDIATE)
1500   {
1501     pCodeOp *pcop = aop->aopu.pcop;
1502     assert (offset <= GPTRSIZE);
1503
1504     /* special case: index >= 2 should return GPOINTER-style values */
1505     if (offset == 2)
1506     {
1507       pcop = popGetLit (aop->code ? GPTRTAG_CODE : GPTRTAG_DATA);
1508       return pcop;
1509     }
1510
1511     pcop = pCodeOpCopy (pcop);
1512     /* usually we want to access the memory at "<symbol> + offset" (using ->index),
1513      * but sometimes we want to access the high byte of the symbol's address (using ->offset) */
1514     PCOI(pcop)->offset += offset;
1515     PCOI(pcop)->index += index;
1516     //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);
1517     return pcop;
1518   } else {
1519     return popGet (aop, offset + index);
1520   }
1521 }
1522
1523 /*-----------------------------------------------------------------*/
1524 /* aopPut - puts a string for a aop                                */
1525 /*-----------------------------------------------------------------*/
1526 void aopPut (asmop *aop, char *s, int offset)
1527 {
1528     char *d = buffer ;
1529     symbol *lbl ;
1530
1531     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1532
1533     if (aop->size && offset > ( aop->size - 1)) {
1534         werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1535             "aopPut got offset > aop->size");
1536         exit(0);
1537     }
1538
1539     /* will assign value to value */
1540     /* depending on where it is ofcourse */
1541     switch (aop->type) {
1542     case AOP_DIR:
1543         if (offset) {
1544             sprintf(d,"(%s + %d)",
1545                 aop->aopu.aop_dir,offset);
1546             fprintf(stderr,"oops aopPut:AOP_DIR did this %s\n",s);
1547
1548         } else
1549             sprintf(d,"%s",aop->aopu.aop_dir);
1550
1551         if (strcmp(d,s)) {
1552             DEBUGpic14_emitcode(";","%d",__LINE__);
1553             if(strcmp(s,"W"))
1554                 pic14_emitcode("movf","%s,w",s);
1555             pic14_emitcode("movwf","%s",d);
1556
1557             if(strcmp(s,"W")) {
1558                 pic14_emitcode(";BUG!? should have this:movf","%s,w   %d",s,__LINE__);
1559                 if(offset >= aop->size) {
1560                     emitpcode(POC_CLRF,popGet(aop,offset));
1561                     break;
1562                 } else {
1563                     emitpcode(POC_MOVFW, popGetImmd(s,0,offset,0));
1564                 }
1565             }
1566             emitpcode(POC_MOVWF,popGet(aop,offset));
1567
1568         }
1569         break;
1570
1571     case AOP_REG:
1572         if (strcmp(aop->aopu.aop_reg[offset]->name,s) != 0) {
1573             //strcmp(aop->aopu.aop_reg[offset]->dname,s)!= 0){
1574             /*
1575             if (*s == '@'         ||
1576             strcmp(s,"r0") == 0 ||
1577             strcmp(s,"r1") == 0 ||
1578             strcmp(s,"r2") == 0 ||
1579             strcmp(s,"r3") == 0 ||
1580             strcmp(s,"r4") == 0 ||
1581             strcmp(s,"r5") == 0 ||
1582             strcmp(s,"r6") == 0 ||
1583             strcmp(s,"r7") == 0 )
1584             pic14_emitcode("mov","%s,%s  ; %d",
1585             aop->aopu.aop_reg[offset]->dname,s,__LINE__);
1586             else
1587             */
1588
1589             if(strcmp(s,"W")==0 )
1590                 pic14_emitcode("movf","%s,w  ; %d",s,__LINE__);
1591
1592             pic14_emitcode("movwf","%s",
1593                 aop->aopu.aop_reg[offset]->name);
1594
1595             if(strcmp(s,zero)==0) {
1596                 emitpcode(POC_CLRF,popGet(aop,offset));
1597
1598             } else if(strcmp(s,"W")==0) {
1599                 pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
1600                 pcop->type = PO_GPR_REGISTER;
1601
1602                 PCOR(pcop)->rIdx = -1;
1603                 PCOR(pcop)->r = NULL;
1604
1605                 DEBUGpic14_emitcode(";","%d",__LINE__);
1606                 pcop->name = Safe_strdup(s);
1607                 emitpcode(POC_MOVFW,pcop);
1608                 emitpcode(POC_MOVWF,popGet(aop,offset));
1609             } else if(strcmp(s,one)==0) {
1610                 emitpcode(POC_CLRF,popGet(aop,offset));
1611                 emitpcode(POC_INCF,popGet(aop,offset));
1612             } else {
1613                 emitpcode(POC_MOVWF,popGet(aop,offset));
1614             }
1615         }
1616         break;
1617
1618     case AOP_DPTR:
1619     case AOP_DPTR2:
1620
1621         if (aop->type == AOP_DPTR2)
1622         {
1623             genSetDPTR(1);
1624         }
1625
1626         if (aop->code) {
1627             werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1628                 "aopPut writting to code space");
1629             exit(0);
1630         }
1631
1632         while (offset > aop->coff) {
1633             aop->coff++;
1634             pic14_emitcode ("inc","dptr");
1635         }
1636
1637         while (offset < aop->coff) {
1638             aop->coff-- ;
1639             pic14_emitcode("lcall","__decdptr");
1640         }
1641
1642         aop->coff = offset;
1643
1644         /* if not in accumulater */
1645         MOVA(s);
1646
1647         pic14_emitcode ("movx","@dptr,a");
1648
1649         if (aop->type == AOP_DPTR2)
1650         {
1651             genSetDPTR(0);
1652         }
1653         break;
1654
1655     case AOP_R0:
1656     case AOP_R1:
1657         while (offset > aop->coff) {
1658             aop->coff++;
1659             pic14_emitcode("inc","%s",aop->aopu.aop_ptr->name);
1660         }
1661         while (offset < aop->coff) {
1662             aop->coff-- ;
1663             pic14_emitcode ("dec","%s",aop->aopu.aop_ptr->name);
1664         }
1665         aop->coff = offset;
1666
1667         if (aop->paged) {
1668             MOVA(s);
1669             pic14_emitcode("movx","@%s,a",aop->aopu.aop_ptr->name);
1670
1671         } else
1672             if (*s == '@') {
1673                 MOVA(s);
1674                 pic14_emitcode("mov","@%s,a ; %d",aop->aopu.aop_ptr->name,__LINE__);
1675             } else
1676                 if (strcmp(s,"r0") == 0 ||
1677                     strcmp(s,"r1") == 0 ||
1678                     strcmp(s,"r2") == 0 ||
1679                     strcmp(s,"r3") == 0 ||
1680                     strcmp(s,"r4") == 0 ||
1681                     strcmp(s,"r5") == 0 ||
1682                     strcmp(s,"r6") == 0 ||
1683                     strcmp(s,"r7") == 0 ) {
1684                     char buffer[10];
1685                     sprintf(buffer,"a%s",s);
1686                     pic14_emitcode("mov","@%s,%s",
1687                         aop->aopu.aop_ptr->name,buffer);
1688                 } else
1689                     pic14_emitcode("mov","@%s,%s",aop->aopu.aop_ptr->name,s);
1690
1691                 break;
1692
1693     case AOP_STK:
1694         if (strcmp(s,"a") == 0)
1695             pic14_emitcode("push","acc");
1696         else
1697             pic14_emitcode("push","%s",s);
1698
1699         break;
1700
1701     case AOP_CRY:
1702         /* if bit variable */
1703         if (!aop->aopu.aop_dir) {
1704             pic14_emitcode("clr","a");
1705             pic14_emitcode("rlc","a");
1706         } else {
1707             if (s == zero)
1708                 pic14_emitcode("clr","%s",aop->aopu.aop_dir);
1709             else
1710                 if (s == one)
1711                     pic14_emitcode("setb","%s",aop->aopu.aop_dir);
1712                 else
1713                     if (!strcmp(s,"c"))
1714                         pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
1715                     else {
1716                         lbl = newiTempLabel(NULL);
1717
1718                         if (strcmp(s,"a")) {
1719                             MOVA(s);
1720                         }
1721                         pic14_emitcode("clr","c");
1722                         pic14_emitcode("jz","%05d_DS_",lbl->key+100);
1723                         pic14_emitcode("cpl","c");
1724                         pic14_emitcode("","%05d_DS_:",lbl->key+100);
1725                         pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
1726                     }
1727         }
1728         break;
1729
1730     case AOP_STR:
1731         aop->coff = offset;
1732         if (strcmp(aop->aopu.aop_str[offset],s))
1733             pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s,__LINE__);
1734         break;
1735
1736     case AOP_ACC:
1737         aop->coff = offset;
1738         if (!offset && (strcmp(s,"acc") == 0))
1739             break;
1740
1741         if (strcmp(aop->aopu.aop_str[offset],s))
1742             pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s, __LINE__);
1743         break;
1744
1745     default :
1746         werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1747             "aopPut got unsupported aop->type");
1748         exit(0);
1749     }
1750
1751 }
1752
1753 /*-----------------------------------------------------------------*/
1754 /* mov2w_op - generate either a MOVLW or MOVFW based operand type  */
1755 /*-----------------------------------------------------------------*/
1756 static void mov2w_op (operand *op, int offset)
1757 {
1758     assert (op);
1759     FENTRY;
1760
1761     /* for PO_IMMEDIATEs: use address or value? */
1762     if (op_isLitLike (op))
1763     {
1764         /* access address of op */
1765         if (AOP_TYPE(op) != AOP_LIT) { assert (offset < 3); }
1766         if (IS_SYMOP(op) && IS_GENPTR(OP_SYM_TYPE(op)) && AOP_SIZE(op) < offset)
1767         {
1768             if (offset == GPTRSIZE-1)
1769                 emitpcode (POC_MOVLW, popGetLit (GPTRTAG_DATA));
1770             else
1771                 emitpcode (POC_MOVLW, popGetLit (0));
1772         }
1773         else
1774             emitpcode (POC_MOVLW, popGetAddr(AOP(op), offset, 0));
1775     } else {
1776         /* access value stored in op */
1777         mov2w (AOP(op), offset);
1778     }
1779 }
1780
1781
1782 /*-----------------------------------------------------------------*/
1783 /* mov2w - generate either a MOVLW or MOVFW based operand type     */
1784 /*-----------------------------------------------------------------*/
1785 void mov2w (asmop *aop, int offset)
1786 {
1787
1788     if(!aop)
1789         return;
1790
1791     DEBUGpic14_emitcode ("; ***","%s  %d  offset=%d",__FUNCTION__,__LINE__,offset);
1792
1793     if ( aop_isLitLike (aop) )
1794         emitpcode(POC_MOVLW,popGetAddr(aop,offset,0));
1795     else
1796         emitpcode(POC_MOVFW,popGet(aop,offset));
1797
1798 }
1799
1800 static void movwf (asmop *op, int offset)
1801 {
1802     emitpcode (POC_MOVWF, popGet(op, offset));
1803 }
1804
1805 static pCodeOp *get_argument_pcop (int idx)
1806 {
1807     assert (idx > 0 && "the 0th (first) argument is passed via WREG");
1808     return popRegFromIdx (Gstack_base_addr - (idx - 1));
1809 }
1810
1811 static pCodeOp *get_return_val_pcop (int offset)
1812 {
1813     assert (offset > 0 && "the most significant byte is returned via WREG");
1814     return popRegFromIdx (Gstack_base_addr - (offset - 1));
1815 }
1816
1817 static void pass_argument (operand *op, int offset, int idx)
1818 {
1819     if (op)
1820         mov2w_op (op, offset);
1821     if (idx != 0)
1822         emitpcode(POC_MOVWF, get_argument_pcop (idx));
1823 }
1824
1825 static void get_returnvalue (operand *op, int offset, int idx)
1826 {
1827     if (idx != 0)
1828         emitpcode(POC_MOVFW, get_return_val_pcop (idx));
1829     movwf(AOP(op), offset);
1830 }
1831
1832 static void call_libraryfunc (char *name)
1833 {
1834     symbol *sym;
1835
1836     /* library code might reside in different page... */
1837     emitpcode (POC_PAGESEL, popGetWithString (name, 1));
1838     /* call the library function */
1839     emitpcode (POC_CALL, popGetExternal (name, 0));
1840     /* might return from different page... */
1841     emitpcode (POC_PAGESEL, popGetWithString ("$", 0));
1842
1843     /* create symbol, mark it as `extern' */
1844     sym = findSym(SymbolTab, NULL, name);
1845     if (!sym) {
1846     sym = newSymbol(name, 0);
1847     strncpy(sym->rname, name, SDCC_NAME_MAX);
1848     addSym(SymbolTab, sym, sym->rname, 0, 0, 0);
1849     addSet(&externs, sym);
1850     } // if
1851     sym->used++;
1852 }
1853
1854 #if 0
1855 /*-----------------------------------------------------------------*/
1856 /* reAdjustPreg - points a register back to where it should        */
1857 /*-----------------------------------------------------------------*/
1858 static void reAdjustPreg (asmop *aop)
1859 {
1860     int size ;
1861
1862     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1863     aop->coff = 0;
1864     if ((size = aop->size) <= 1)
1865         return ;
1866     size-- ;
1867     switch (aop->type) {
1868     case AOP_R0 :
1869     case AOP_R1 :
1870         while (size--)
1871             pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
1872         break;
1873     case AOP_DPTR :
1874     case AOP_DPTR2:
1875         if (aop->type == AOP_DPTR2)
1876         {
1877             genSetDPTR(1);
1878         }
1879         while (size--)
1880         {
1881             pic14_emitcode("lcall","__decdptr");
1882         }
1883
1884         if (aop->type == AOP_DPTR2)
1885         {
1886             genSetDPTR(0);
1887         }
1888         break;
1889
1890     }
1891
1892 }
1893 #endif
1894
1895
1896 #if 0
1897 /*-----------------------------------------------------------------*/
1898 /* opIsGptr: returns non-zero if the passed operand is             */
1899 /* a generic pointer type.                                         */
1900 /*-----------------------------------------------------------------*/
1901 static int opIsGptr(operand *op)
1902 {
1903     sym_link *type = operandType(op);
1904
1905     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1906     if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type))
1907     {
1908         return 1;
1909     }
1910     return 0;
1911 }
1912 #endif
1913
1914 /*-----------------------------------------------------------------*/
1915 /* pic14_getDataSize - get the operand data size                   */
1916 /*-----------------------------------------------------------------*/
1917 int pic14_getDataSize(operand *op)
1918 {
1919     int size;
1920
1921     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1922
1923 #if 0
1924     size = getSize(OP_SYM_ETYPE(op));
1925     return size;
1926     //return AOP_SIZE(op);
1927
1928     // tsd- in the pic port, the genptr size is 1, so this code here
1929     // fails. ( in the 8051 port, the size was 4).
1930 #else
1931     size = AOP_SIZE(op);
1932     if (IS_GENPTR(OP_SYM_TYPE(op)))
1933     {
1934         sym_link *type = operandType(op);
1935         if (IS_GENPTR(type))
1936         {
1937             /* generic pointer; arithmetic operations
1938             * should ignore the high byte (pointer type).
1939             */
1940             size--;
1941             DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1942         }
1943     }
1944     return size;
1945 #endif
1946 }
1947
1948 /*-----------------------------------------------------------------*/
1949 /* pic14_outAcc - output Acc                                       */
1950 /*-----------------------------------------------------------------*/
1951 void pic14_outAcc(operand *result)
1952 {
1953     int size,offset;
1954     DEBUGpic14_emitcode ("; ***","%s  %d - ",__FUNCTION__,__LINE__);
1955     DEBUGpic14_AopType(__LINE__,NULL,NULL,result);
1956
1957
1958     size = pic14_getDataSize(result);
1959     if(size){
1960         emitpcode(POC_MOVWF,popGet(AOP(result),0));
1961         size--;
1962         offset = 1;
1963         /* unsigned or positive */
1964         while(size--)
1965             emitpcode(POC_CLRF,popGet(AOP(result),offset++));
1966     }
1967
1968 }
1969
1970 /*-----------------------------------------------------------------*/
1971 /* pic14_outBitC - output a bit C                                  */
1972 /*-----------------------------------------------------------------*/
1973 void pic14_outBitC(operand *result)
1974 {
1975
1976     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1977     /* if the result is bit */
1978     if (AOP_TYPE(result) == AOP_CRY)
1979         aopPut(AOP(result),"c",0);
1980     else {
1981         pic14_emitcode("clr","a  ; %d", __LINE__);
1982         pic14_emitcode("rlc","a");
1983         pic14_outAcc(result);
1984     }
1985 }
1986
1987 /*-----------------------------------------------------------------*/
1988 /* pic14_toBoolean - emit code for orl a,operator(sizeop)          */
1989 /*-----------------------------------------------------------------*/
1990 void pic14_toBoolean(operand *oper)
1991 {
1992     int size = AOP_SIZE(oper);
1993     int offset = 0;
1994
1995     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1996
1997     assert (size > 0);
1998
1999     if (size == 1) {
2000         /* MOVFW does not load the flags... */
2001         if (AOP_TYPE(oper) == AOP_ACC) {
2002             emitpcode(POC_IORLW, popGetLit(0));
2003             offset = 1;
2004         } else {
2005             emitpcode(POC_MOVLW, popGetLit(0));
2006             offset = 0;
2007         }
2008     } else {
2009         if ( AOP_TYPE(oper) != AOP_ACC) {
2010             emitpcode(POC_MOVFW,popGet(AOP(oper),0));
2011             offset = 1;
2012         }
2013     }
2014
2015     while (offset < size) {
2016         emitpcode(POC_IORFW, popGet(AOP(oper),offset++));
2017     }
2018     /* Z is set iff (oper == 0) */
2019 }
2020
2021
2022 /*-----------------------------------------------------------------*/
2023 /* genNot - generate code for ! operation                          */
2024 /*-----------------------------------------------------------------*/
2025 static void genNot (iCode *ic)
2026 {
2027     //symbol *tlbl;
2028     int size;
2029
2030     FENTRY;
2031
2032     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2033     /* assign asmOps to operand & result */
2034     aopOp (IC_LEFT(ic),ic,FALSE);
2035     aopOp (IC_RESULT(ic),ic,TRUE);
2036
2037     DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),NULL,IC_RESULT(ic));
2038     /* if in bit space then a special case */
2039     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
2040         if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
2041             emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(ic)),0));
2042             emitpcode(POC_XORWF,popGet(AOP(IC_RESULT(ic)),0));
2043         } else {
2044             emitpcode(POC_CLRF,popGet(AOP(IC_RESULT(ic)),0));
2045             emitpcode(POC_BTFSS,popGet(AOP(IC_LEFT(ic)),0));
2046             emitpcode(POC_INCF,popGet(AOP(IC_RESULT(ic)),0));
2047         }
2048         goto release;
2049     }
2050
2051     size = AOP_SIZE(IC_LEFT(ic));
2052     mov2w (AOP(IC_LEFT(ic)),0);
2053     while (--size > 0)
2054     {
2055       if (op_isLitLike (IC_LEFT(ic)))
2056         emitpcode (POC_IORLW, popGetAddr (AOP(IC_LEFT(ic)), size, 0));
2057       else
2058         emitpcode (POC_IORFW, popGet (AOP(IC_LEFT(ic)), size));
2059     }
2060     emitpcode(POC_MOVLW, popGetLit (0));
2061     emitSKPNZ;
2062     emitpcode(POC_MOVLW, popGetLit (1));
2063     movwf(AOP(IC_RESULT(ic)), 0);
2064
2065     for (size = 1; size < AOP_SIZE(IC_RESULT(ic)); size++)
2066     {
2067       emitpcode(POC_CLRF, popGet (AOP(IC_RESULT(ic)), size));
2068     }
2069     goto release;
2070
2071 release:
2072     /* release the aops */
2073     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
2074     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
2075 }
2076
2077
2078 /*-----------------------------------------------------------------*/
2079 /* genCpl - generate code for complement                           */
2080 /*-----------------------------------------------------------------*/
2081 static void genCpl (iCode *ic)
2082 {
2083     operand *left, *result;
2084     int size, offset=0;
2085
2086     FENTRY;
2087
2088     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2089     aopOp((left = IC_LEFT(ic)),ic,FALSE);
2090     aopOp((result=IC_RESULT(ic)),ic,TRUE);
2091
2092     /* if both are in bit space then
2093     a special case */
2094     if (AOP_TYPE(result) == AOP_CRY &&
2095         AOP_TYPE(left) == AOP_CRY ) {
2096
2097         pic14_emitcode("mov","c,%s",left->aop->aopu.aop_dir);
2098         pic14_emitcode("cpl","c");
2099         pic14_emitcode("mov","%s,c",result->aop->aopu.aop_dir);
2100         goto release;
2101     }
2102
2103     size = AOP_SIZE(result);
2104     if (AOP_SIZE(left) < size) size = AOP_SIZE(left);
2105     while (size--) {
2106
2107         if(AOP_TYPE(left) == AOP_ACC)
2108             emitpcode(POC_XORLW, popGetLit(0xff));
2109         else
2110             emitpcode(POC_COMFW,popGet(AOP(left),offset));
2111
2112         emitpcode(POC_MOVWF,popGet(AOP(result),offset));
2113         offset++;
2114     }
2115     addSign (result, AOP_SIZE(left), !SPEC_USIGN(operandType(result)));
2116
2117
2118 release:
2119     /* release the aops */
2120     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
2121     freeAsmop(result,NULL,ic,TRUE);
2122 }
2123
2124 /*-----------------------------------------------------------------*/
2125 /* genUminusFloat - unary minus for floating points                */
2126 /*-----------------------------------------------------------------*/
2127 static void genUminusFloat(operand *op,operand *result)
2128 {
2129     int size ,offset =0 ;
2130     char *l;
2131
2132     FENTRY;
2133
2134     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2135     /* for this we just need to flip the
2136     first it then copy the rest in place */
2137     size = AOP_SIZE(op) - 1;
2138     l = aopGet(AOP(op),3,FALSE,FALSE);
2139
2140     MOVA(l);
2141
2142     pic14_emitcode("cpl","acc.7");
2143     aopPut(AOP(result),"a",3);
2144
2145     while(size--) {
2146         aopPut(AOP(result),
2147             aopGet(AOP(op),offset,FALSE,FALSE),
2148             offset);
2149         offset++;
2150     }
2151 }
2152
2153 /*-----------------------------------------------------------------*/
2154 /* genUminus - unary minus code generation                         */
2155 /*-----------------------------------------------------------------*/
2156 static void genUminus (iCode *ic)
2157 {
2158     int size, i;
2159     sym_link *optype, *rtype;
2160
2161     FENTRY;
2162
2163     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2164     /* assign asmops */
2165     aopOp(IC_LEFT(ic),ic,FALSE);
2166     aopOp(IC_RESULT(ic),ic,TRUE);
2167
2168     /* if both in bit space then special
2169     case */
2170     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
2171         AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
2172
2173         emitpcode(POC_BCF,   popGet(AOP(IC_RESULT(ic)),0));
2174         emitpcode(POC_BTFSS, popGet(AOP(IC_LEFT(ic)),0));
2175         emitpcode(POC_BSF,   popGet(AOP(IC_RESULT(ic)),0));
2176
2177         goto release;
2178     }
2179
2180     optype = operandType(IC_LEFT(ic));
2181     rtype = operandType(IC_RESULT(ic));
2182
2183     /* if float then do float stuff */
2184     if (IS_FLOAT(optype)) {
2185         genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
2186         goto release;
2187     }
2188
2189     /* otherwise subtract from zero by taking the 2's complement */
2190     size = AOP_SIZE(IC_LEFT(ic));
2191
2192     for(i=0; i<size; i++) {
2193         if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
2194             emitpcode(POC_COMF,  popGet(AOP(IC_LEFT(ic)),i));
2195         else {
2196             emitpcode(POC_COMFW, popGet(AOP(IC_LEFT(ic)),i));
2197             emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),i));
2198         }
2199     }
2200
2201     emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),0));
2202     for(i=1; i<size; i++) {
2203         emitSKPNZ;
2204         emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),i));
2205     }
2206
2207 release:
2208     /* release the aops */
2209     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
2210     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
2211 }
2212
2213 /*-----------------------------------------------------------------*/
2214 /* saveRegisters - will look for a call and save the registers     */
2215 /*-----------------------------------------------------------------*/
2216 static void saveRegisters(iCode *lic)
2217 {
2218     int i;
2219     iCode *ic;
2220     bitVect *rsave;
2221     sym_link *dtype;
2222
2223     FENTRY;
2224
2225     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2226     /* look for call */
2227     for (ic = lic ; ic ; ic = ic->next)
2228         if (ic->op == CALL || ic->op == PCALL)
2229             break;
2230
2231         if (!ic) {
2232             fprintf(stderr,"found parameter push with no function call\n");
2233             return ;
2234         }
2235
2236         /* if the registers have been saved already then
2237         do nothing */
2238         if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type))
2239             return ;
2240
2241             /* find the registers in use at this time
2242         and push them away to safety */
2243         rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
2244             ic->rUsed);
2245
2246         ic->regsSaved = 1;
2247         if (options.useXstack) {
2248             if (bitVectBitValue(rsave,R0_IDX))
2249                 pic14_emitcode("mov","b,r0");
2250             pic14_emitcode("mov","r0,%s",spname);
2251             for (i = 0 ; i < pic14_nRegs ; i++) {
2252                 if (bitVectBitValue(rsave,i)) {
2253                     if (i == R0_IDX)
2254                         pic14_emitcode("mov","a,b");
2255                     else
2256                         pic14_emitcode("mov","a,%s",pic14_regWithIdx(i)->name);
2257                     pic14_emitcode("movx","@r0,a");
2258                     pic14_emitcode("inc","r0");
2259                 }
2260             }
2261             pic14_emitcode("mov","%s,r0",spname);
2262             if (bitVectBitValue(rsave,R0_IDX))
2263                 pic14_emitcode("mov","r0,b");
2264         }// else
2265         //for (i = 0 ; i < pic14_nRegs ; i++) {
2266         //    if (bitVectBitValue(rsave,i))
2267         //  pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
2268         //}
2269
2270         dtype = operandType(IC_LEFT(ic));
2271         if (currFunc && dtype &&
2272             (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
2273             IFFUNC_ISISR(currFunc->type) &&
2274             !ic->bankSaved)
2275
2276             saverbank(FUNC_REGBANK(dtype),ic,TRUE);
2277
2278 }
2279 /*-----------------------------------------------------------------*/
2280 /* unsaveRegisters - pop the pushed registers                      */
2281 /*-----------------------------------------------------------------*/
2282 static void unsaveRegisters (iCode *ic)
2283 {
2284     int i;
2285     bitVect *rsave;
2286
2287     FENTRY;
2288
2289     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2290     /* find the registers in use at this time
2291     and push them away to safety */
2292     rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
2293         ic->rUsed);
2294
2295     if (options.useXstack) {
2296         pic14_emitcode("mov","r0,%s",spname);
2297         for (i =  pic14_nRegs ; i >= 0 ; i--) {
2298             if (bitVectBitValue(rsave,i)) {
2299                 pic14_emitcode("dec","r0");
2300                 pic14_emitcode("movx","a,@r0");
2301                 if (i == R0_IDX)
2302                     pic14_emitcode("mov","b,a");
2303                 else
2304                     pic14_emitcode("mov","%s,a",pic14_regWithIdx(i)->name);
2305             }
2306
2307         }
2308         pic14_emitcode("mov","%s,r0",spname);
2309         if (bitVectBitValue(rsave,R0_IDX))
2310             pic14_emitcode("mov","r0,b");
2311     } //else
2312     //for (i =  pic14_nRegs ; i >= 0 ; i--) {
2313     //  if (bitVectBitValue(rsave,i))
2314     //  pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
2315     //}
2316
2317 }
2318
2319
2320 /*-----------------------------------------------------------------*/
2321 /* pushSide -                */
2322 /*-----------------------------------------------------------------*/
2323 static void pushSide(operand * oper, int size)
2324 {
2325 #if 0
2326     int offset = 0;
2327     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2328     while (size--) {
2329         char *l = aopGet(AOP(oper),offset++,FALSE,TRUE);
2330         if (AOP_TYPE(oper) != AOP_REG &&
2331             AOP_TYPE(oper) != AOP_DIR &&
2332             strcmp(l,"a") ) {
2333             pic14_emitcode("mov","a,%s",l);
2334             pic14_emitcode("push","acc");
2335         } else
2336             pic14_emitcode("push","%s",l);
2337     }
2338 #endif
2339 }
2340
2341 /*-----------------------------------------------------------------*/
2342 /* assignResultValue -               */
2343 /*-----------------------------------------------------------------*/
2344 static void assignResultValue(operand * oper)
2345 {
2346     int size = AOP_SIZE(oper);
2347     int offset = 0;
2348
2349     FENTRY;
2350
2351     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2352
2353     DEBUGpic14_AopType(__LINE__,oper,NULL,NULL);
2354
2355     /* assign MSB first (passed via WREG) */
2356     while (size--) {
2357         get_returnvalue (oper, size, offset + GpsuedoStkPtr);
2358         GpsuedoStkPtr++;
2359     }
2360 }
2361
2362
2363 /*-----------------------------------------------------------------*/
2364 /* genIpush - genrate code for pushing this gets a little complex  */
2365 /*-----------------------------------------------------------------*/
2366 static void genIpush (iCode *ic)
2367 {
2368     FENTRY;
2369
2370     DEBUGpic14_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
2371 #if 0
2372     int size, offset = 0 ;
2373     char *l;
2374
2375
2376     /* if this is not a parm push : ie. it is spill push
2377     and spill push is always done on the local stack */
2378     if (!ic->parmPush) {
2379
2380         /* and the item is spilt then do nothing */
2381         if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
2382             return ;
2383
2384         aopOp(IC_LEFT(ic),ic,FALSE);
2385         size = AOP_SIZE(IC_LEFT(ic));
2386         /* push it on the stack */
2387         while(size--) {
2388             l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
2389             if (*l == '#') {
2390                 MOVA(l);
2391                 l = "acc";
2392             }
2393             pic14_emitcode("push","%s",l);
2394         }
2395         return ;
2396     }
2397
2398     /* this is a paramter push: in this case we call
2399     the routine to find the call and save those
2400     registers that need to be saved */
2401     saveRegisters(ic);
2402
2403     /* then do the push */
2404     aopOp(IC_LEFT(ic),ic,FALSE);
2405
2406
2407     // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
2408     size = AOP_SIZE(IC_LEFT(ic));
2409
2410     while (size--) {
2411         l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
2412         if (AOP_TYPE(IC_LEFT(ic)) != AOP_REG &&
2413             AOP_TYPE(IC_LEFT(ic)) != AOP_DIR &&
2414             strcmp(l,"a") ) {
2415             pic14_emitcode("mov","a,%s",l);
2416             pic14_emitcode("push","acc");
2417         } else
2418             pic14_emitcode("push","%s",l);
2419     }
2420
2421     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
2422 #endif
2423 }
2424
2425 /*-----------------------------------------------------------------*/
2426 /* genIpop - recover the registers: can happen only for spilling   */
2427 /*-----------------------------------------------------------------*/
2428 static void genIpop (iCode *ic)
2429 {
2430     FENTRY;
2431
2432     DEBUGpic14_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
2433     assert (!"genIpop -- unimplemented");
2434 #if 0
2435     int size,offset ;
2436
2437
2438     /* if the temp was not pushed then */
2439     if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
2440         return ;
2441
2442     aopOp(IC_LEFT(ic),ic,FALSE);
2443     size = AOP_SIZE(IC_LEFT(ic));
2444     offset = (size-1);
2445     while (size--)
2446         pic14_emitcode("pop","%s",aopGet(AOP(IC_LEFT(ic)),offset--,
2447         FALSE,TRUE));
2448
2449     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
2450 #endif
2451 }
2452
2453 /*-----------------------------------------------------------------*/
2454 /* unsaverbank - restores the resgister bank from stack            */
2455 /*-----------------------------------------------------------------*/
2456 static void unsaverbank (int bank,iCode *ic,bool popPsw)
2457 {
2458     FENTRY;
2459
2460     DEBUGpic14_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
2461 #if 0
2462     int i;
2463     asmop *aop ;
2464     regs *r = NULL;
2465
2466     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2467     if (popPsw) {
2468         if (options.useXstack) {
2469             aop = newAsmop(0);
2470             r = getFreePtr(ic,&aop,FALSE);
2471
2472
2473             pic14_emitcode("mov","%s,_spx",r->name);
2474             pic14_emitcode("movx","a,@%s",r->name);
2475             pic14_emitcode("mov","psw,a");
2476             pic14_emitcode("dec","%s",r->name);
2477
2478         }else
2479             pic14_emitcode ("pop","psw");
2480     }
2481
2482     for (i = (pic14_nRegs - 1) ; i >= 0 ;i--) {
2483         if (options.useXstack) {
2484             pic14_emitcode("movx","a,@%s",r->name);
2485             //pic14_emitcode("mov","(%s+%d),a",
2486             //     regspic14[i].base,8*bank+regspic14[i].offset);
2487             pic14_emitcode("dec","%s",r->name);
2488
2489         } else
2490             pic14_emitcode("pop",""); //"(%s+%d)",
2491         //regspic14[i].base,8*bank); //+regspic14[i].offset);
2492     }
2493
2494     if (options.useXstack) {
2495
2496         pic14_emitcode("mov","_spx,%s",r->name);
2497         freeAsmop(NULL,aop,ic,TRUE);
2498
2499     }
2500 #endif
2501 }
2502
2503 /*-----------------------------------------------------------------*/
2504 /* saverbank - saves an entire register bank on the stack          */
2505 /*-----------------------------------------------------------------*/
2506 static void saverbank (int bank, iCode *ic, bool pushPsw)
2507 {
2508     FENTRY;
2509
2510     DEBUGpic14_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
2511 #if 0
2512     int i;
2513     asmop *aop ;
2514     regs *r = NULL;
2515
2516     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2517     if (options.useXstack) {
2518
2519         aop = newAsmop(0);
2520         r = getFreePtr(ic,&aop,FALSE);
2521         pic14_emitcode("mov","%s,_spx",r->name);
2522
2523     }
2524
2525     for (i = 0 ; i < pic14_nRegs ;i++) {
2526         if (options.useXstack) {
2527             pic14_emitcode("inc","%s",r->name);
2528             //pic14_emitcode("mov","a,(%s+%d)",
2529             //       regspic14[i].base,8*bank+regspic14[i].offset);
2530             pic14_emitcode("movx","@%s,a",r->name);
2531         } else
2532             pic14_emitcode("push","");// "(%s+%d)",
2533         //regspic14[i].base,8*bank+regspic14[i].offset);
2534     }
2535
2536     if (pushPsw) {
2537         if (options.useXstack) {
2538             pic14_emitcode("mov","a,psw");
2539             pic14_emitcode("movx","@%s,a",r->name);
2540             pic14_emitcode("inc","%s",r->name);
2541             pic14_emitcode("mov","_spx,%s",r->name);
2542             freeAsmop (NULL,aop,ic,TRUE);
2543
2544         } else
2545             pic14_emitcode("push","psw");
2546
2547         pic14_emitcode("mov","psw,#0x%02x",(bank << 3)&0x00ff);
2548     }
2549     ic->bankSaved = 1;
2550 #endif
2551 }
2552
2553 /*-----------------------------------------------------------------*/
2554 /* genCall - generates a call statement                            */
2555 /*-----------------------------------------------------------------*/
2556 static void genCall (iCode *ic)
2557 {
2558     sym_link *dtype;
2559     symbol *sym;
2560     char *name;
2561     int isExtern;
2562
2563     FENTRY;
2564
2565     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2566
2567     /* if caller saves & we have not saved then */
2568     if (!ic->regsSaved)
2569         saveRegisters(ic);
2570
2571         /* if we are calling a function that is not using
2572         the same register bank then we need to save the
2573     destination registers on the stack */
2574     dtype = operandType(IC_LEFT(ic));
2575     if (currFunc && dtype &&
2576         (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
2577         IFFUNC_ISISR(currFunc->type) &&
2578         !ic->bankSaved)
2579
2580         saverbank(FUNC_REGBANK(dtype),ic,TRUE);
2581
2582     /* if send set is not empty the assign */
2583     if (_G.sendSet) {
2584         iCode *sic;
2585         /* For the Pic port, there is no data stack.
2586         * So parameters passed to functions are stored
2587         * in registers. (The pCode optimizer will get
2588         * rid of most of these :).
2589         */
2590         int psuedoStkPtr=-1;
2591         int firstTimeThruLoop = 1;
2592
2593         _G.sendSet = reverseSet(_G.sendSet);
2594
2595         /* First figure how many parameters are getting passed */
2596         for (sic = setFirstItem(_G.sendSet) ; sic ;
2597         sic = setNextItem(_G.sendSet)) {
2598
2599             aopOp(IC_LEFT(sic),sic,FALSE);
2600             psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
2601             freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
2602         }
2603
2604         for (sic = setFirstItem(_G.sendSet) ; sic ;
2605         sic = setNextItem(_G.sendSet)) {
2606             int size, offset = 0;
2607
2608             aopOp(IC_LEFT(sic),sic,FALSE);
2609             size = AOP_SIZE(IC_LEFT(sic));
2610
2611             while (size--) {
2612                 DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
2613                     AopType(AOP_TYPE(IC_LEFT(sic))));
2614
2615                 if(!firstTimeThruLoop) {
2616                     /* If this is not the first time we've been through the loop
2617                     * then we need to save the parameter in a temporary
2618                     * register. The last byte of the last parameter is
2619                     * passed in W. */
2620                     emitpcode(POC_MOVWF,popRegFromIdx(Gstack_base_addr - --psuedoStkPtr));
2621
2622                 }
2623                 firstTimeThruLoop=0;
2624
2625                 mov2w_op (IC_LEFT(sic),  offset);
2626                 offset++;
2627             }
2628             freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
2629         }
2630         _G.sendSet = NULL;
2631     }
2632     /* make the call */
2633     sym = OP_SYMBOL(IC_LEFT(ic));
2634     name = sym->rname[0] ? sym->rname : sym->name;
2635     /*
2636      * As SDCC emits code as soon as it reaches the end of each
2637      * function's definition, prototyped functions that are implemented
2638      * after the current one are always considered EXTERN, which
2639      * introduces many unneccessary PAGESEL instructions.
2640      * XXX: Use a post pass to iterate over all `CALL _name' statements
2641      * and insert `PAGESEL _name' and `PAGESEL $' around the CALL
2642      * only iff there is no definition of the function in the whole
2643      * file (might include this in the PAGESEL pass).
2644      */
2645     isExtern = IS_EXTERN(sym->etype) || pic14_inISR;
2646     if (isExtern) {
2647         /* Extern functions and ISRs maybe on a different page;
2648          * must call pagesel */
2649         emitpcode(POC_PAGESEL,popGetWithString(name,1));
2650     }
2651     emitpcode(POC_CALL,popGetWithString(name,isExtern));
2652     if (isExtern) {
2653         /* May have returned from a different page;
2654          * must use pagesel to restore PCLATH before next
2655          * goto or call instruction */
2656         emitpcode(POC_PAGESEL,popGetWithString("$",0));
2657     }
2658     GpsuedoStkPtr=0;
2659     /* if we need assign a result value */
2660     if ((IS_ITEMP(IC_RESULT(ic)) &&
2661         (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
2662         OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
2663         IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
2664
2665         _G.accInUse++;
2666         aopOp(IC_RESULT(ic),ic,FALSE);
2667         _G.accInUse--;
2668
2669         assignResultValue(IC_RESULT(ic));
2670
2671         DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
2672             AopType(AOP_TYPE(IC_RESULT(ic))));
2673
2674         freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
2675     }
2676
2677     /* if register bank was saved then pop them */
2678     if (ic->bankSaved)
2679         unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
2680
2681     /* if we hade saved some registers then unsave them */
2682     if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
2683         unsaveRegisters (ic);
2684
2685
2686 }
2687
2688 /*-----------------------------------------------------------------*/
2689 /* genPcall - generates a call by pointer statement                */
2690 /*-----------------------------------------------------------------*/
2691 static void genPcall (iCode *ic)
2692 {
2693     sym_link *dtype;
2694     symbol *albl = newiTempLabel(NULL);
2695     symbol *blbl = newiTempLabel(NULL);
2696     PIC_OPCODE poc;
2697     pCodeOp *pcop;
2698     operand *left;
2699
2700     FENTRY;
2701
2702     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2703     /* if caller saves & we have not saved then */
2704     if (!ic->regsSaved)
2705         saveRegisters(ic);
2706
2707         /* if we are calling a function that is not using
2708         the same register bank then we need to save the
2709     destination registers on the stack */
2710     dtype = operandType(IC_LEFT(ic));
2711     if (currFunc && dtype &&
2712         IFFUNC_ISISR(currFunc->type) &&
2713         (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
2714         saverbank(FUNC_REGBANK(dtype),ic,TRUE);
2715
2716     left = IC_LEFT(ic);
2717     aopOp(left,ic,FALSE);
2718     DEBUGpic14_AopType(__LINE__,left,NULL,NULL);
2719
2720     poc = ( op_isLitLike (IC_LEFT(ic)) ? POC_MOVLW : POC_MOVFW );
2721
2722     pushSide(IC_LEFT(ic), FPTRSIZE);
2723
2724     /* if send set is not empty, assign parameters */
2725     if (_G.sendSet) {
2726
2727         DEBUGpic14_emitcode ("; ***","%s  %d - WARNING arg-passing to indirect call not supported",__FUNCTION__,__LINE__);
2728         /* no way to pass args - W always gets used to make the call */
2729     }
2730     /* first idea - factor out a common helper function and call it.
2731     But don't know how to get it generated only once in its own block
2732
2733     if(AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) {
2734         char *rname;
2735         char *buffer;
2736         rname = IC_LEFT(ic)->aop->aopu.aop_dir;
2737         DEBUGpic14_emitcode ("; ***","%s  %d AOP_DIR %s",__FUNCTION__,__LINE__,rname);
2738         buffer = Safe_calloc(1,strlen(rname)+16);
2739         sprintf(buffer, "%s_goto_helper", rname);
2740         addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp(buffer,PO_STR)));
2741         free(buffer);
2742     }
2743     */
2744     emitpcode(POC_CALL,popGetLabel(albl->key));
2745     pcop = popGetLabel(blbl->key);
2746     emitpcode(POC_PAGESEL,pcop); /* Must restore PCLATH before goto, without destroying W */
2747     emitpcode(POC_GOTO,pcop);
2748     emitpLabel(albl->key);
2749
2750     emitpcode(poc,popGetAddr(AOP(left),1,0));
2751     emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
2752     emitpcode(poc,popGetAddr(AOP(left),0,0));
2753     emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
2754
2755     emitpLabel(blbl->key);
2756
2757     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
2758
2759     /* if we need to assign a result value */
2760     if ((IS_ITEMP(IC_RESULT(ic)) &&
2761         (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
2762         OP_SYMBOL(IC_RESULT(ic))->spildir)) ||
2763         IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
2764
2765         _G.accInUse++;
2766         aopOp(IC_RESULT(ic),ic,FALSE);
2767         _G.accInUse--;
2768
2769         GpsuedoStkPtr = 0;
2770
2771         assignResultValue(IC_RESULT(ic));
2772
2773         freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
2774     }
2775
2776     /* if register bank was saved then unsave them */
2777     if (currFunc && dtype &&
2778         (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
2779         unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
2780
2781         /* if we hade saved some registers then
2782     unsave them */
2783     if (ic->regsSaved)
2784         unsaveRegisters (ic);
2785
2786 }
2787
2788 /*-----------------------------------------------------------------*/
2789 /* resultRemat - result  is rematerializable                       */
2790 /*-----------------------------------------------------------------*/
2791 static int resultRemat (iCode *ic)
2792 {
2793     //  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2794     FENTRY;
2795
2796     if (SKIP_IC(ic) || ic->op == IFX)
2797         return 0;
2798
2799     if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
2800         symbol *sym = OP_SYMBOL(IC_RESULT(ic));
2801         if (sym->remat && !POINTER_SET(ic))
2802             return 1;
2803     }
2804
2805     return 0;
2806 }
2807
2808 #if 0
2809 /*-----------------------------------------------------------------*/
2810 /* inExcludeList - return 1 if the string is in exclude Reg list   */
2811 /*-----------------------------------------------------------------*/
2812 static bool inExcludeList(char *s)
2813 {
2814     DEBUGpic14_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
2815     int i =0;
2816
2817     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2818     if (options.excludeRegs[i] &&
2819         STRCASECMP(options.excludeRegs[i],"none") == 0)
2820         return FALSE ;
2821
2822     for ( i = 0 ; options.excludeRegs[i]; i++) {
2823         if (options.excludeRegs[i] &&
2824             STRCASECMP(s,options.excludeRegs[i]) == 0)
2825             return TRUE;
2826     }
2827     return FALSE ;
2828 }
2829 #endif
2830
2831 /*-----------------------------------------------------------------*/
2832 /* genFunction - generated code for function entry                 */
2833 /*-----------------------------------------------------------------*/
2834 static void genFunction (iCode *ic)
2835 {
2836     symbol *sym;
2837     sym_link *ftype;
2838
2839     FENTRY;
2840
2841     DEBUGpic14_emitcode ("; ***","%s  %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
2842
2843     labelOffset += (max_key+4);
2844     max_key=0;
2845     GpsuedoStkPtr=0;
2846     _G.nRegsSaved = 0;
2847     /* create the function header */
2848     pic14_emitcode(";","-----------------------------------------");
2849     pic14_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
2850     pic14_emitcode(";","-----------------------------------------");
2851
2852     /* prevent this symbol from being emitted as 'extern' */
2853     pic14_stringInSet(sym->rname, &pic14_localFunctions, 1);
2854
2855     pic14_emitcode("","%s:",sym->rname);
2856     addpCode2pBlock(pb,newpCodeFunction(NULL,sym->rname,!IS_STATIC (sym->etype)));
2857
2858     /* mark symbol as NOT extern (even if it was declared so previously) */
2859     assert(IS_SPEC(sym->etype));
2860     SPEC_EXTR(sym->etype) = 0;
2861     sym->cdef = 0;
2862     if (!SPEC_OCLS(sym->etype)) SPEC_OCLS(sym->etype) = code;
2863     addSetIfnotP(&SPEC_OCLS(sym->etype)->syms, sym);
2864
2865     ftype = operandType(IC_LEFT(ic));
2866
2867     /* if critical function then turn interrupts off */
2868     if (IFFUNC_ISCRITICAL(ftype))
2869         pic14_emitcode("clr","ea");
2870
2871         /* here we need to generate the equates for the
2872     register bank if required */
2873 #if 0
2874     if (FUNC_REGBANK(ftype) != rbank) {
2875         int i ;
2876
2877         rbank = FUNC_REGBANK(ftype);
2878         for ( i = 0 ; i < pic14_nRegs ; i++ ) {
2879             if (strcmp(regspic14[i].base,"0") == 0)
2880                 pic14_emitcode("","%s = 0x%02x",
2881                 regspic14[i].dname,
2882                 8*rbank+regspic14[i].offset);
2883             else
2884                 pic14_emitcode ("","%s = %s + 0x%02x",
2885                 regspic14[i].dname,
2886                 regspic14[i].base,
2887                 8*rbank+regspic14[i].offset);
2888         }
2889     }
2890 #endif
2891
2892     /* if this is an interrupt service routine */
2893     pic14_inISR = 0;
2894     if (IFFUNC_ISISR(sym->type)) {
2895         pic14_inISR = 1;
2896         emitpcode(POC_MOVWF,  popCopyReg(&pc_wsave));
2897         emitpcode(POC_SWAPFW, popCopyReg(&pc_status));
2898         /* XXX: Why? Does this assume that ssave and psave reside
2899          * in a shared bank or bank0? We cannot guarantee the
2900          * latter...
2901          */
2902         emitpcode(POC_CLRF,   popCopyReg(&pc_status));
2903         emitpcode(POC_MOVWF,  popCopyReg(&pc_ssave));
2904         //emitpcode(POC_MOVWF,  popGetExternal("___sdcc_saved_status",1 ));
2905         emitpcode(POC_MOVFW,  popCopyReg(&pc_pclath));
2906         /* during an interrupt PCLATH must be cleared before a goto or call statement */
2907         emitpcode(POC_CLRF,   popCopyReg(&pc_pclath));
2908         emitpcode(POC_MOVWF,  popCopyReg(&pc_psave));
2909         //emitpcode(POC_MOVWF,  popGetExternal("___sdcc_saved_pclath", 1));
2910         emitpcode(POC_MOVFW,  popCopyReg(&pc_fsr));
2911         emitpcode(POC_MOVWF,  popGetExternal("___sdcc_saved_fsr", 1));
2912
2913         pBlockConvert2ISR(pb);
2914         pic14_hasInterrupt = 1;
2915     } else {
2916     /* if callee-save to be used for this function
2917         then save the registers being used in this function */
2918         if (IFFUNC_CALLEESAVES(sym->type)) {
2919             int i;
2920
2921             /* if any registers used */
2922             if (sym->regsUsed) {
2923                 /* save the registers used */
2924                 for ( i = 0 ; i < sym->regsUsed->size ; i++) {
2925                     if (bitVectBitValue(sym->regsUsed,i) ||
2926                         (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
2927                         //pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
2928                         _G.nRegsSaved++;
2929                     }
2930                 }
2931             }
2932         }
2933     }
2934
2935     /* set the register bank to the desired value */
2936     if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type)) {
2937         pic14_emitcode("push","psw");
2938         pic14_emitcode("mov","psw,#0x%02x",(FUNC_REGBANK(sym->type) << 3)&0x00ff);
2939     }
2940
2941     if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
2942
2943         if (options.useXstack) {
2944             pic14_emitcode("mov","r0,%s",spname);
2945             pic14_emitcode("mov","a,_bp");
2946             pic14_emitcode("movx","@r0,a");
2947             pic14_emitcode("inc","%s",spname);
2948         }
2949         else
2950         {
2951             /* set up the stack */
2952             pic14_emitcode ("push","_bp");   /* save the callers stack  */
2953         }
2954         pic14_emitcode ("mov","_bp,%s",spname);
2955     }
2956
2957     /* adjust the stack for the function */
2958     if (sym->stack) {
2959
2960         int i = sym->stack;
2961         if (i > 256 )
2962             werror(W_STACK_OVERFLOW,sym->name);
2963
2964         if (i > 3 && sym->recvSize < 4) {
2965
2966             pic14_emitcode ("mov","a,sp");
2967             pic14_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
2968             pic14_emitcode ("mov","sp,a");
2969
2970         }
2971         else
2972             while(i--)
2973                 pic14_emitcode("inc","sp");
2974     }
2975
2976     if (sym->xstack) {
2977
2978         pic14_emitcode ("mov","a,_spx");
2979         pic14_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
2980         pic14_emitcode ("mov","_spx,a");
2981     }
2982
2983 }
2984
2985 /*-----------------------------------------------------------------*/
2986 /* genEndFunction - generates epilogue for functions               */
2987 /*-----------------------------------------------------------------*/
2988 static void genEndFunction (iCode *ic)
2989 {
2990     symbol *sym = OP_SYMBOL(IC_LEFT(ic));
2991
2992     FENTRY;
2993
2994     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
2995
2996     if (IFFUNC_ISREENT(sym->type) || options.stackAuto)
2997     {
2998         pic14_emitcode ("mov","%s,_bp",spname);
2999     }
3000
3001     /* if use external stack but some variables were
3002     added to the local stack then decrement the
3003     local stack */
3004     if (options.useXstack && sym->stack) {
3005         pic14_emitcode("mov","a,sp");
3006         pic14_emitcode("add","a,#0x%02x",((char)-sym->stack) & 0xff);
3007         pic14_emitcode("mov","sp,a");
3008     }
3009
3010
3011     if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) {
3012         if (options.useXstack) {
3013             pic14_emitcode("mov","r0,%s",spname);
3014             pic14_emitcode("movx","a,@r0");
3015             pic14_emitcode("mov","_bp,a");
3016             pic14_emitcode("dec","%s",spname);
3017         }
3018         else
3019         {
3020             pic14_emitcode ("pop","_bp");
3021         }
3022     }
3023
3024     /* restore the register bank    */
3025     if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type))
3026         pic14_emitcode ("pop","psw");
3027
3028     if (IFFUNC_ISISR(sym->type)) {
3029
3030         /* now we need to restore the registers */
3031         /* if this isr has no bank i.e. is going to
3032         run with bank 0 , then we need to save more
3033 registers :-) */
3034         if (!FUNC_REGBANK(sym->type)) {
3035
3036         /* if this function does not call any other
3037         function then we can be economical and
3038             save only those registers that are used */
3039             if (! IFFUNC_HASFCALL(sym->type)) {
3040                 int i;
3041
3042                 /* if any registers used */
3043                 if (sym->regsUsed) {
3044                     /* save the registers used */
3045                     for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
3046                         if (bitVectBitValue(sym->regsUsed,i) ||
3047                             (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
3048                             pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
3049                     }
3050                 }
3051
3052             } else {
3053             /* this function has    a function call cannot
3054             determines register usage so we will have the
3055                 entire bank */
3056                 unsaverbank(0,ic,FALSE);
3057             }
3058         }
3059
3060         /* if debug then send end of function */
3061         if (options.debug && debugFile && currFunc) {
3062             debugFile->writeEndFunction (currFunc, ic, 1);
3063         }
3064
3065         emitpcode(POC_MOVFW,  popGetExternal("___sdcc_saved_fsr", 1));
3066         emitpcode(POC_MOVWF,  popCopyReg(&pc_fsr));
3067         //emitpcode(POC_MOVFW,  popGetExternal("___sdcc_saved_pclath", 1));
3068         emitpcode(POC_MOVFW,  popCopyReg(&pc_psave));
3069         emitpcode(POC_MOVWF,  popCopyReg(&pc_pclath));
3070         emitpcode(POC_CLRF,   popCopyReg(&pc_status)); // see genFunction
3071         //emitpcode(POC_SWAPFW, popGetExternal("___sdcc_saved_status", 1));
3072         emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
3073         emitpcode(POC_MOVWF,  popCopyReg(&pc_status));
3074         emitpcode(POC_SWAPF,  popCopyReg(&pc_wsave));
3075         emitpcode(POC_SWAPFW, popCopyReg(&pc_wsave));
3076         addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
3077         emitpcodeNULLop(POC_RETFIE);
3078     }
3079     else {
3080         if (IFFUNC_ISCRITICAL(sym->type))
3081             pic14_emitcode("setb","ea");
3082
3083         if (IFFUNC_CALLEESAVES(sym->type)) {
3084             int i;
3085
3086             /* if any registers used */
3087             if (sym->regsUsed) {
3088                 /* save the registers used */
3089                 for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
3090                     if (bitVectBitValue(sym->regsUsed,i) ||
3091                         (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
3092                         pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
3093                 }
3094             }
3095
3096         }
3097
3098         /* if debug then send end of function */
3099         if (options.debug && debugFile && currFunc) {
3100             debugFile->writeEndFunction (currFunc, ic, 1);
3101         }
3102
3103         pic14_emitcode ("return","");
3104         emitpcodeNULLop(POC_RETURN);
3105
3106         /* Mark the end of a function */
3107         addpCode2pBlock(pb,newpCodeFunction(NULL,NULL,0));
3108     }
3109
3110 }
3111
3112 /*-----------------------------------------------------------------*/
3113 /* genRet - generate code for return statement                     */
3114 /*-----------------------------------------------------------------*/
3115 static void genRet (iCode *ic)
3116 {
3117     int size,offset = 0;
3118
3119     FENTRY;
3120
3121     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3122     /* if we have no return value then
3123     just generate the "ret" */
3124     if (!IC_LEFT(ic))
3125         goto jumpret;
3126
3127         /* we have something to return then
3128     move the return value into place */
3129     aopOp(IC_LEFT(ic),ic,FALSE);
3130     size = AOP_SIZE(IC_LEFT(ic));
3131
3132     for (offset = 0; offset < size; offset++)
3133     {
3134         pass_argument (IC_LEFT(ic), offset, size - 1 - offset);
3135     }
3136
3137     freeAsmop (IC_LEFT(ic),NULL,ic,TRUE);
3138
3139 jumpret:
3140     /* generate a jump to the return label
3141     if the next is not the return statement */
3142     if (!(ic->next && ic->next->op == LABEL &&
3143         IC_LABEL(ic->next) == returnLabel)) {
3144
3145         emitpcode(POC_GOTO,popGetLabel(returnLabel->key));
3146     }
3147
3148 }
3149
3150 /*-----------------------------------------------------------------*/
3151 /* genLabel - generates a label                                    */
3152 /*-----------------------------------------------------------------*/
3153 static void genLabel (iCode *ic)
3154 {
3155     FENTRY;
3156
3157     /* special case never generate */
3158     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3159     if (IC_LABEL(ic) == entryLabel)
3160         return ;
3161
3162     emitpLabel(IC_LABEL(ic)->key);
3163     pic14_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + labelOffset));
3164 }
3165
3166 /*-----------------------------------------------------------------*/
3167 /* genGoto - generates a goto                                      */
3168 /*-----------------------------------------------------------------*/
3169 //tsd
3170 static void genGoto (iCode *ic)
3171 {
3172     FENTRY;
3173
3174     emitpcode(POC_GOTO,popGetLabel(IC_LABEL(ic)->key));
3175     pic14_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+labelOffset);
3176 }
3177
3178
3179 /*-----------------------------------------------------------------*/
3180 /* genMultbits :- multiplication of bits                           */
3181 /*-----------------------------------------------------------------*/
3182 static void genMultbits (operand *left,
3183                          operand *right,
3184                          operand *result)
3185 {
3186     FENTRY;
3187     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3188
3189     if(!pic14_sameRegs(AOP(result),AOP(right)))
3190         emitpcode(POC_BSF,  popGet(AOP(result),0));
3191
3192     emitpcode(POC_BTFSC,popGet(AOP(right),0));
3193     emitpcode(POC_BTFSS,popGet(AOP(left),0));
3194     emitpcode(POC_BCF,  popGet(AOP(result),0));
3195
3196 }
3197
3198
3199 /*-----------------------------------------------------------------*/
3200 /* genMultOneByte : 8 bit multiplication & division                */
3201 /*-----------------------------------------------------------------*/
3202 static void genMultOneByte (operand *left,
3203                             operand *right,
3204                             operand *result)
3205 {
3206     char *func[] = { NULL, "__mulchar", "__mulint", NULL, "__mullong" };
3207
3208     // symbol *lbl ;
3209     int size,offset,i;
3210
3211
3212     FENTRY;
3213
3214     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3215     DEBUGpic14_AopType(__LINE__,left,right,result);
3216     DEBUGpic14_AopTypeSign(__LINE__,left,right,result);
3217
3218     /* (if two literals, the value is computed before) */
3219     /* if one literal, literal on the right */
3220     if (AOP_TYPE(left) == AOP_LIT){
3221         operand *t = right;
3222         right = left;
3223         left = t;
3224     }
3225
3226     assert (AOP_SIZE(left) == AOP_SIZE(right));
3227
3228     size = min(AOP_SIZE(result),AOP_SIZE(left));
3229     offset = Gstack_base_addr - (2*size - 1);
3230
3231     /* pass right operand as argument */
3232     for (i=0; i < size; i++)
3233     {
3234         mov2w (AOP(right), i);
3235         emitpcode(POC_MOVWF, popRegFromIdx (++offset));
3236     } // for
3237
3238     /* pass left operand as argument */
3239     for (i=0; i < size; i++)
3240     {
3241         mov2w (AOP(left), i);
3242         if (i != size-1) emitpcode(POC_MOVWF, popRegFromIdx (++offset));
3243     } // for
3244     assert (offset == Gstack_base_addr);
3245
3246     /* call library routine */
3247     assert (size > 0 && size <= 4);
3248     call_libraryfunc (func[size]);
3249
3250     /* assign result */
3251     movwf (AOP(result), size-1);
3252     for (i=0; i < size - 1; i++)
3253     {
3254         emitpcode(POC_MOVFW, popRegFromIdx (Gstack_base_addr - i));
3255         movwf (AOP(result), size - 2 - i);
3256     } // for
3257
3258     /* now (zero-/sign) extend the result to its size */
3259     addSign (result, AOP_SIZE(left), !SPEC_USIGN(operandType(result)));
3260 }
3261
3262 /*-----------------------------------------------------------------*/
3263 /* genMult - generates code for multiplication                     */
3264 /*-----------------------------------------------------------------*/
3265 static void genMult (iCode *ic)
3266 {
3267     operand *left = IC_LEFT(ic);
3268     operand *right = IC_RIGHT(ic);
3269     operand *result= IC_RESULT(ic);
3270
3271     FENTRY;
3272
3273     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3274     /* assign the amsops */
3275     aopOp (left,ic,FALSE);
3276     aopOp (right,ic,FALSE);
3277     aopOp (result,ic,TRUE);
3278
3279     DEBUGpic14_AopType(__LINE__,left,right,result);
3280
3281     /* special cases first */
3282     /* both are bits */
3283     if (AOP_TYPE(left) == AOP_CRY &&
3284         AOP_TYPE(right)== AOP_CRY) {
3285         genMultbits(left,right,result);
3286         goto release ;
3287     }
3288
3289     /* if both are of size == 1 */
3290     if (AOP_SIZE(left) == 1 &&
3291         AOP_SIZE(right) == 1 ) {
3292         genMultOneByte(left,right,result);
3293         goto release ;
3294     }
3295
3296     /* should have been converted to function call */
3297     assert(0) ;
3298
3299 release :
3300     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3301     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3302     freeAsmop(result,NULL,ic,TRUE);
3303 }
3304
3305 /*-----------------------------------------------------------------*/
3306 /* genDivbits :- division of bits                                  */
3307 /*-----------------------------------------------------------------*/
3308 static void genDivbits (operand *left,
3309                         operand *right,
3310                         operand *result)
3311 {
3312
3313     char *l;
3314
3315     FENTRY;
3316
3317     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3318     /* the result must be bit */
3319     pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
3320     l = aopGet(AOP(left),0,FALSE,FALSE);
3321
3322     MOVA(l);
3323
3324     pic14_emitcode("div","ab");
3325     pic14_emitcode("rrc","a");
3326     aopPut(AOP(result),"c",0);
3327 }
3328
3329 /*-----------------------------------------------------------------*/
3330 /* genDivOneByte : 8 bit division                                  */
3331 /*-----------------------------------------------------------------*/
3332 static void genDivOneByte (operand *left,
3333                            operand *right,
3334                            operand *result)
3335 {
3336     int size;
3337     int sign;
3338
3339     FENTRY;
3340     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3341
3342     assert (AOP_SIZE(right) == 1);
3343     assert (AOP_SIZE(left) == 1);
3344
3345     size = min(AOP_SIZE(result),AOP_SIZE(left));
3346     sign = !(SPEC_USIGN(operandType(left))
3347         && SPEC_USIGN(operandType(right)));
3348
3349     if (AOP_TYPE(right) == AOP_LIT)
3350     {
3351         /* XXX: might add specialized code */
3352     }
3353
3354     if (!sign)
3355     {
3356         /* unsigned division */
3357     #if 1
3358         mov2w(AOP(right),0);
3359         emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
3360         mov2w(AOP(left),0);
3361         call_libraryfunc("__divuchar");
3362         movwf(AOP(result),0);
3363     #else
3364         pCodeOp *temp;
3365         symbol *lbl;
3366
3367         temp = popGetTempReg();
3368         lbl = newiTempLabel(NULL);
3369
3370         /* XXX: improve this naive approach:
3371            [result] = [a] / [b]
3372             ::= [result] = 0; while ([a] > [b]) do [a] -= [b]; [result]++ done
3373
3374            In PIC assembler:
3375            movf  left,W
3376            movwf temp       // temp <-- left
3377            movf  right,W    // W <-- right
3378            clrf  result
3379            label1:
3380            incf  result
3381            subwf temp,F     // temp <-- temp - W
3382            skipNC       // subwf clears CARRY (i.e. sets BORROW) if temp < W
3383            goto  label1
3384            decf result      // we just subtract once too often
3385          */
3386
3387         /* XXX: This loops endlessly on DIVIDE BY ZERO */
3388         /* We need 1..128 iterations of the loop body (`4 / 5' .. `255 / 2'). */
3389
3390         mov2w(AOP(left),0);
3391         emitpcode(POC_MOVWF, temp);
3392         mov2w(AOP(right),0);
3393         emitpcode(POC_CLRF, popGet(AOP(result),0));
3394
3395         emitpLabel(lbl->key);
3396         emitpcode(POC_INCF, popGet(AOP(result),0));
3397         emitpcode(POC_SUBWF, temp);
3398         emitSKPNC;
3399         emitpcode(POC_GOTO, popGetLabel(lbl->key));
3400         emitpcode(POC_DECF, popGet(AOP(result),0));
3401         popReleaseTempReg(temp);
3402     #endif
3403     }
3404     else
3405     {
3406         /* signed division */
3407         mov2w(AOP(right),0);
3408         emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
3409         mov2w(AOP(left),0);
3410         call_libraryfunc("__divschar");
3411         movwf(AOP(result),0);
3412     }
3413
3414     /* now performed the signed/unsigned division -- extend result */
3415     addSign(result, 1, sign);
3416 }
3417
3418 /*-----------------------------------------------------------------*/
3419 /* genDiv - generates code for division                */
3420 /*-----------------------------------------------------------------*/
3421 static void genDiv (iCode *ic)
3422 {
3423     operand *left = IC_LEFT(ic);
3424     operand *right = IC_RIGHT(ic);
3425     operand *result= IC_RESULT(ic);
3426
3427     FENTRY;
3428     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3429     /* assign the amsops */
3430     aopOp (left,ic,FALSE);
3431     aopOp (right,ic,FALSE);
3432     aopOp (result,ic,TRUE);
3433
3434     /* special cases first */
3435     /* both are bits */
3436     if (AOP_TYPE(left) == AOP_CRY &&
3437         AOP_TYPE(right)== AOP_CRY) {
3438         genDivbits(left,right,result);
3439         goto release ;
3440     }
3441
3442     /* if both are of size == 1 */
3443     if (AOP_SIZE(left) == 1 &&
3444         AOP_SIZE(right) == 1 ) {
3445         genDivOneByte(left,right,result);
3446         goto release ;
3447     }
3448
3449     /* should have been converted to function call */
3450     assert(0);
3451 release :
3452     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3453     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3454     freeAsmop(result,NULL,ic,TRUE);
3455 }
3456
3457 /*-----------------------------------------------------------------*/
3458 /* genModOneByte : 8 bit modulus                                   */
3459 /*-----------------------------------------------------------------*/
3460 static void genModOneByte (operand *left,
3461                            operand *right,
3462                            operand *result)
3463 {
3464     int size;
3465     int sign;
3466
3467     FENTRY;
3468     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3469
3470     assert (AOP_SIZE(right) == 1);
3471     assert (AOP_SIZE(left) == 1);
3472
3473     size = min(AOP_SIZE(result),AOP_SIZE(left));
3474     sign = !(SPEC_USIGN(operandType(left))
3475         && SPEC_USIGN(operandType(right)));
3476
3477     if (AOP_TYPE(right) == AOP_LIT)
3478     {
3479         /* XXX: might add specialized code */
3480     }
3481
3482     if (!sign)
3483     {
3484         /* unsigned division */
3485     #if 1
3486         mov2w(AOP(right),0);
3487         emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
3488         mov2w(AOP(left),0);
3489         call_libraryfunc("__moduchar");
3490         movwf(AOP(result),0);
3491     #else
3492         pCodeOp *temp;
3493         symbol *lbl;
3494
3495         lbl = newiTempLabel(NULL);
3496
3497         assert(!pic14_sameRegs(AOP(right),AOP(result)));
3498
3499         /* XXX: improve this naive approach:
3500            [result] = [a] % [b]
3501             ::= [result] = [a]; while ([result] > [b]) do [result] -= [b]; done
3502
3503            In PIC assembler:
3504            movf  left,W
3505            movwf result     // result <-- left
3506            movf  right,W    // W <-- right
3507            label1:
3508            subwf result,F   // result <-- result - W
3509            skipNC       // subwf clears CARRY (i.e. sets BORROW) if result < W
3510            goto  label1
3511            addwf result, F  // we just subtract once too often
3512          */
3513
3514         /* XXX: This loops endlessly on DIVIDE BY ZERO */
3515         /* We need 1..128 iterations of the loop body (`4 % 5' .. `255 % 2'). */
3516
3517         if (!pic14_sameRegs(AOP(left), AOP(result)))
3518         {
3519             mov2w(AOP(left),0);
3520             emitpcode(POC_MOVWF, popGet(AOP(result),0));
3521         }
3522         mov2w(AOP(right),0);
3523
3524         emitpLabel(lbl->key);
3525         emitpcode(POC_SUBWF, popGet(AOP(result),0));
3526         emitSKPNC;
3527         emitpcode(POC_GOTO, popGetLabel(lbl->key));
3528         emitpcode(POC_ADDWF, popGet(AOP(result),0));
3529     #endif
3530     }
3531     else
3532     {
3533         /* signed division */
3534         mov2w(AOP(right),0);
3535         emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
3536         mov2w(AOP(left),0);
3537         call_libraryfunc("__modschar");
3538         movwf(AOP(result),0);
3539     }
3540
3541     /* now we performed the signed/unsigned modulus -- extend result */
3542     addSign(result, 1, sign);
3543 }
3544
3545 /*-----------------------------------------------------------------*/
3546 /* genMod - generates code for division                            */
3547 /*-----------------------------------------------------------------*/
3548 static void genMod (iCode *ic)
3549 {
3550     operand *left = IC_LEFT(ic);
3551     operand *right = IC_RIGHT(ic);
3552     operand *result= IC_RESULT(ic);
3553
3554     FENTRY;
3555     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3556     /* assign the amsops */
3557     aopOp (left,ic,FALSE);
3558     aopOp (right,ic,FALSE);
3559     aopOp (result,ic,TRUE);
3560
3561     /* if both are of size == 1 */
3562     if (AOP_SIZE(left) == 1 &&
3563         AOP_SIZE(right) == 1 ) {
3564         genModOneByte(left,right,result);
3565         goto release ;
3566     }
3567
3568     /* should have been converted to function call */
3569     assert(0);
3570
3571 release :
3572     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3573     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3574     freeAsmop(result,NULL,ic,TRUE);
3575 }
3576
3577 /*-----------------------------------------------------------------*/
3578 /* genIfxJump :- will create a jump depending on the ifx           */
3579 /*-----------------------------------------------------------------*/
3580 /*
3581 note: May need to add parameter to indicate when a variable is in bit space.
3582 */
3583 static void genIfxJump (iCode *ic, char *jval)
3584 {
3585
3586     FENTRY;
3587     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
3588     /* if true label then we jump if condition
3589     supplied is true */
3590     if ( IC_TRUE(ic) ) {
3591
3592         if(strcmp(jval,"a") == 0)
3593             emitSKPZ;
3594         else if (strcmp(jval,"c") == 0)
3595             emitSKPC;
3596         else {
3597             DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
3598             emitpcode(POC_BTFSC,    newpCodeOpBit(jval,-1,1));
3599         }
3600
3601         emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ic)->key));
3602         pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + labelOffset);
3603
3604     }
3605     else {
3606         /* false label is present */
3607         if(strcmp(jval,"a") == 0)
3608             emitSKPNZ;
3609         else if (strcmp(jval,"c") == 0)
3610             emitSKPNC;
3611         else {
3612             DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
3613             emitpcode(POC_BTFSS,    newpCodeOpBit(jval,-1,1));
3614         }
3615
3616         emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ic)->key));
3617         pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + labelOffset);
3618
3619     }
3620
3621
3622     /* mark the icode as generated */
3623     ic->generated = 1;
3624 }
3625
3626 #if 0
3627 /*-----------------------------------------------------------------*/
3628 /* genSkip                                                         */
3629 /*-----------------------------------------------------------------*/
3630 static void genSkip(iCode *ifx,int status_bit)
3631 {
3632     FENTRY;
3633     if(!ifx)
3634         return;
3635
3636     if ( IC_TRUE(ifx) ) {
3637         switch(status_bit) {
3638         case 'z':
3639             emitSKPNZ;
3640             break;
3641
3642         case 'c':
3643             emitSKPNC;
3644             break;
3645
3646         case 'd':
3647             emitSKPDC;
3648             break;
3649
3650         }
3651
3652         emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
3653         pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
3654
3655     } else {
3656
3657         switch(status_bit) {
3658
3659         case 'z':
3660             emitSKPZ;
3661             break;
3662
3663         case 'c':
3664             emitSKPC;
3665             break;
3666
3667         case 'd':
3668             emitSKPDC;
3669             break;
3670         }
3671         emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
3672         pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
3673
3674     }
3675
3676 }
3677 #endif
3678
3679 /*-----------------------------------------------------------------*/
3680 /* genSkipc                                                        */
3681 /*-----------------------------------------------------------------*/
3682 static void genSkipc(resolvedIfx *rifx)
3683 {
3684     FENTRY;
3685     if(!rifx)
3686         return;
3687
3688     if(rifx->condition)
3689         emitSKPNC;
3690     else
3691         emitSKPC;
3692
3693     emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
3694     emitpComment ("%s:%u: created from rifx:%p", __FUNCTION__, __LINE__, rifx);
3695     rifx->generated = 1;
3696 }
3697
3698 #if 0
3699 /*-----------------------------------------------------------------*/
3700 /* genSkipz2                                                       */
3701 /*-----------------------------------------------------------------*/
3702 static void genSkipz2(resolvedIfx *rifx, int invert_condition)
3703 {
3704     FENTRY;
3705     if(!rifx)
3706         return;
3707
3708     if( (rifx->condition ^ invert_condition) & 1)
3709         emitSKPZ;
3710     else
3711         emitSKPNZ;
3712
3713     emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
3714     rifx->generated = 1;
3715 }
3716 #endif
3717
3718 #if 0
3719 /*-----------------------------------------------------------------*/
3720 /* genSkipz                                                        */
3721 /*-----------------------------------------------------------------*/
3722 static void genSkipz(iCode *ifx, int condition)
3723 {
3724     FENTRY;
3725     assert (ifx != NULL);
3726
3727     if(condition)
3728         emitSKPNZ;
3729     else
3730         emitSKPZ;
3731
3732     if ( IC_TRUE(ifx) )
3733         emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
3734     else
3735         emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
3736
3737     if ( IC_TRUE(ifx) )
3738         pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
3739     else
3740         pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
3741
3742 }
3743 #endif
3744
3745 #if 0
3746 /*-----------------------------------------------------------------*/
3747 /* genSkipCond                                                     */
3748 /*-----------------------------------------------------------------*/
3749 static void genSkipCond(resolvedIfx *rifx,operand *op, int offset, int bit)
3750 {
3751     FENTRY;
3752     if(!rifx)
3753         return;
3754
3755     if(rifx->condition)
3756         emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
3757     else
3758         emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
3759
3760
3761     emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
3762     rifx->generated = 1;
3763 }
3764 #endif
3765
3766 #if 0
3767 /*-----------------------------------------------------------------*/
3768 /* genChkZeroes :- greater or less than comparison                 */
3769 /*     For each byte in a literal that is zero, inclusive or the   */
3770 /*     the corresponding byte in the operand with W                */
3771 /*     returns true if any of the bytes are zero                   */
3772 /*-----------------------------------------------------------------*/
3773 static int genChkZeroes(operand *op, int lit,  int size)
3774 {
3775
3776     int i;
3777     int flag =1;
3778
3779     while(size--) {
3780         i = (lit >> (size*8)) & 0xff;
3781
3782         if(i==0) {
3783             if(flag)
3784                 emitpcode(POC_MOVFW, popGet(AOP(op),size));
3785             else
3786                 emitpcode(POC_IORFW, popGet(AOP(op),size));
3787             flag = 0;
3788         }
3789     }
3790
3791     return (flag==0);
3792 }
3793 #endif
3794
3795
3796 #define isAOP_REGlike(x)  (AOP_TYPE(x) == AOP_REG || AOP_TYPE(x) == AOP_DIR || AOP_TYPE(x) == AOP_PCODE)
3797 #define isAOP_LIT(x)      (AOP_TYPE(x) == AOP_LIT)
3798 #define DEBUGpc           emitpComment
3799
3800 /*-----------------------------------------------------------------*/
3801 /* mov2w_regOrLit :- move to WREG either the offset's byte from    */
3802 /*                  aop (if it's NOT a literal) or from lit (if    */
3803 /*                  aop is a literal)                              */
3804 /*-----------------------------------------------------------------*/
3805 void pic14_mov2w_regOrLit (asmop *aop, unsigned long lit, int offset) {
3806   if (aop->type == AOP_LIT) {
3807     emitpcode (POC_MOVLW, popGetLit((lit >> (offset*8)) & 0x00FF));
3808   } else {
3809     emitpcode (POC_MOVFW, popGet (aop, offset));
3810   }
3811 }
3812
3813 /* genCmp performs a left < right comparison, stores
3814  * the outcome in result (if != NULL) and generates
3815  * control flow code for the ifx (if != NULL).
3816  *
3817  * This version leaves in sequences like
3818  * "B[CS]F STATUS,0; BTFS[CS] STATUS,0"
3819  * which should be optmized by the peephole
3820  * optimizer - RN 2005-01-01 */
3821 static void genCmp (operand *left,operand *right,
3822                     operand *result, iCode *ifx, int sign)
3823 {
3824   resolvedIfx rIfx;
3825   int size;
3826   int offs;
3827   symbol *templbl;
3828   operand *dummy;
3829   unsigned long lit;
3830   unsigned long mask;
3831   int performedLt;
3832   int invert_result = 0;
3833
3834   FENTRY;
3835
3836   assert (AOP_SIZE(left) == AOP_SIZE(right));
3837   assert (left && right);
3838
3839   size = AOP_SIZE(right) - 1;
3840   mask = (0x100UL << (size*8)) - 1;
3841   // in the end CARRY holds "left < right" (performedLt == 1) or "left >= right" (performedLt == 0)
3842   performedLt = 1;
3843   templbl = NULL;
3844   lit = 0;
3845
3846   resolveIfx (&rIfx, ifx);
3847
3848   /**********************************************************************
3849    * handle bits - bit compares are promoted to int compares seemingly! *
3850    **********************************************************************/
3851 #if 0
3852   // THIS IS COMPLETELY UNTESTED!
3853   if (AOP_TYPE(left) == AOP_CRY && AOP_TYPE(right) == AOP_CRY) {
3854     pCodeOp *pcleft = pic16_popGet(AOP(left), 0);
3855     pCodeOp *pcright = pic16_popGet(AOP(right), 0);
3856     assert (pcleft->type == PO_GPR_BIT && pcright->type == PO_GPR_BIT);
3857
3858     emitSETC;
3859     // 1 < {0,1} is false --> clear C by skipping the next instruction
3860     //pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (AOP(left),0), PCORB(pcleft)->bit);
3861     pic16_emitpcode (POC_BTFSS, pic16_popGet (AOP(left), 0));
3862     // {0,1} < 0 is false --> clear C by NOT skipping the next instruction
3863     pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (pic16_popGet(AOP(right),0), PCORB(pcright)->bit));
3864     emitCLRC; // only skipped for left=0 && right=1
3865
3866     goto correct_result_in_carry;
3867   } // if
3868 #endif
3869
3870   /*************************************************
3871    * make sure that left is register (or the like) *
3872    *************************************************/
3873   if (!isAOP_REGlike(left)) {
3874     DEBUGpc ("swapping arguments (AOP_TYPEs %d/%d)", AOP_TYPE(left), AOP_TYPE(right));
3875     assert (isAOP_LIT(left));
3876     assert (isAOP_REGlike(right));
3877     // swap left and right
3878     // left < right <==> right > left <==> (right >= left + 1)
3879     lit = ulFromVal(AOP(left)->aopu.aop_lit);
3880
3881     if ( (!sign && (lit & mask) == mask) || (sign && (lit & mask) == (mask >> 1)) ) {
3882       // MAXVALUE < right? always false
3883       if (performedLt) emitCLRC; else emitSETC;
3884       goto correct_result_in_carry;
3885     } // if
3886
3887     // This fails for lit = 0xFF (unsigned) AND lit = 0x7F (signed),
3888     // that's why we handled it above.
3889     lit++;
3890
3891     dummy = left;
3892     left = right;
3893     right = dummy;
3894
3895     performedLt ^= 1; // instead of "left < right" we check for "right >= left+1, i.e. "right < left+1"
3896   } else if (isAOP_LIT(right)) {
3897     lit = ulFromVal(AOP(right)->aopu.aop_lit);
3898   } // if
3899
3900   assert (isAOP_REGlike(left)); // left must be register or the like
3901   assert (isAOP_REGlike(right) || isAOP_LIT(right)); // right may be register-like or a literal
3902
3903   /*************************************************
3904    * special cases go here                         *
3905    *************************************************/
3906
3907   if (isAOP_LIT(right)) {
3908     if (!sign) {
3909       // unsigned comparison to a literal
3910       DEBUGpc ("unsigned compare: left %s lit(0x%X=%lu), size=%d", performedLt ? "<" : ">=", lit, lit, size+1);
3911       if (lit == 0) {
3912     // unsigned left < 0? always false
3913     if (performedLt) emitCLRC; else emitSETC;
3914     goto correct_result_in_carry;
3915       }
3916     } else {
3917       // signed comparison to a literal
3918       DEBUGpc ("signed compare: left %s lit(0x%X=%ld), size=%d, mask=%x", performedLt ? "<" : ">=", lit, lit, size+1, mask);
3919       if ((lit & mask) == ((0x80 << (size*8)) & mask)) {
3920     // signed left < 0x80000000? always false
3921     if (performedLt) emitCLRC; else emitSETC;
3922     goto correct_result_in_carry;
3923       } else if (lit == 0) {
3924     // compare left < 0; set CARRY if SIGNBIT(left) is set
3925     if (performedLt) emitSETC; else emitCLRC;
3926     emitpcode (POC_BTFSS, newpCodeOpBit (aopGet (AOP(left), size, FALSE, FALSE), 7, 0));
3927     if (performedLt) emitCLRC; else emitSETC;
3928     goto correct_result_in_carry;
3929       }
3930     } // if (!sign)
3931   } // right is literal
3932
3933   /*************************************************
3934    * perform a general case comparison             *
3935    * make sure we get CARRY==1 <==> left >= right  *
3936    *************************************************/
3937   // compare most significant bytes
3938   //DEBUGpc ("comparing bytes at offset %d", size);
3939   if (!sign) {
3940     // unsigned comparison
3941     pic14_mov2w_regOrLit (AOP(right), lit, size);
3942     emitpcode (POC_SUBFW, popGet (AOP(left), size));
3943   } else {
3944     // signed comparison
3945     // (add 2^n to both operands then perform an unsigned comparison)
3946     if (isAOP_LIT(right)) {
3947       // left >= LIT <-> LIT-left <= 0 <-> LIT-left == 0 OR !(LIT-left >= 0)
3948       unsigned char litbyte = (lit >> (8*size)) & 0xFF;
3949
3950       if (litbyte == 0x80) {
3951     // left >= 0x80 -- always true, but more bytes to come
3952     mov2w (AOP(left), size);
3953     emitpcode (POC_XORLW, popGetLit (0x80)); // set ZERO flag
3954     emitSETC;
3955       } else {
3956     // left >= LIT <-> left + (-LIT) >= 0 <-> left + (0x100-LIT) >= 0x100
3957     mov2w (AOP(left), size);
3958     emitpcode (POC_ADDLW, popGetLit (0x80));
3959     emitpcode (POC_ADDLW, popGetLit ((0x100 - (litbyte + 0x80)) & 0x00FF));
3960       } // if
3961     } else {
3962       pCodeOp *pctemp = popGetTempReg();
3963       mov2w (AOP(left), size);
3964       emitpcode (POC_ADDLW, popGetLit (0x80));
3965       emitpcode (POC_MOVWF, pctemp);
3966       mov2w (AOP(right), size);
3967       emitpcode (POC_ADDLW, popGetLit (0x80));
3968       emitpcode (POC_SUBFW, pctemp);
3969       popReleaseTempReg(pctemp);
3970     }
3971   } // if (!sign)
3972
3973   // compare remaining bytes (treat as unsigned case from above)
3974   templbl = newiTempLabel ( NULL );
3975   offs = size;
3976   while (offs--) {
3977     //DEBUGpc ("comparing bytes at offset %d", offs);
3978     emitSKPZ;
3979     emitpcode (POC_GOTO, popGetLabel (templbl->key));
3980     pic14_mov2w_regOrLit (AOP(right), lit, offs);
3981     emitpcode (POC_SUBFW, popGet (AOP(left), offs));
3982   } // while (offs)
3983   emitpLabel (templbl->key);
3984   goto result_in_carry;
3985
3986 result_in_carry:
3987
3988   /****************************************************
3989    * now CARRY contains the result of the comparison: *
3990    * SUBWF sets CARRY iff                             *
3991    * F-W >= 0 <==> F >= W <==> !(F < W)               *
3992    * (F=left, W=right)                                *
3993    ****************************************************/
3994
3995   if (performedLt) {
3996     invert_result = 1;
3997     // value will be used in the following genSkipc()
3998     rIfx.condition ^= 1;
3999   } // if
4000
4001 correct_result_in_carry:
4002
4003   // assign result to variable (if neccessary)
4004   if (result && AOP_TYPE(result) != AOP_CRY) {
4005     //DEBUGpc ("assign result");
4006     size = AOP_SIZE(result);
4007     while (size--) {
4008       emitpcode (POC_CLRF, popGet (AOP(result), size));
4009     } // while
4010     if (invert_result) {
4011       emitSKPC;
4012       emitpcode (POC_BSF, newpCodeOpBit (aopGet (AOP(result), 0, FALSE, FALSE), 0, 0));
4013     } else {
4014       emitpcode (POC_RLF, popGet (AOP(result), 0));
4015     }
4016   } // if (result)
4017
4018   // perform conditional jump
4019   if (ifx) {
4020     //DEBUGpc ("generate control flow");
4021     genSkipc (&rIfx);
4022     ifx->generated = 1;
4023   } // if
4024 }
4025
4026
4027 #if 0
4028 /* OLD VERSION -- BUGGY, DO NOT USE */
4029
4030 /*-----------------------------------------------------------------*/
4031 /* genCmp :- greater or less than comparison                       */
4032 /*-----------------------------------------------------------------*/
4033 static void genCmp (operand *left,operand *right,
4034                     operand *result, iCode *ifx, int sign)
4035 {
4036     int size; //, offset = 0 ;
4037     unsigned long lit = 0L,i = 0;
4038     resolvedIfx rFalseIfx;
4039     //  resolvedIfx rTrueIfx;
4040     symbol *truelbl;
4041
4042     FENTRY;
4043     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4044     /*
4045     if(ifx) {
4046     DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
4047     DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
4048     }
4049     */
4050
4051     resolveIfx(&rFalseIfx,ifx);
4052     truelbl  = newiTempLabel(NULL);
4053     size = max(AOP_SIZE(left),AOP_SIZE(right));
4054
4055     DEBUGpic14_AopType(__LINE__,left,right,result);
4056
4057 #define _swapp
4058
4059     /* if literal is on the right then swap with left */
4060     if ((AOP_TYPE(right) == AOP_LIT)) {
4061         operand *tmp = right ;
4062         unsigned long mask = (0x100 << (8*(size-1))) - 1;
4063         lit = ulFromVal(AOP(right)->aopu.aop_lit);
4064 #ifdef _swapp
4065
4066         lit = (lit - 1) & mask;
4067         right = left;
4068         left = tmp;
4069         rFalseIfx.condition ^= 1;
4070 #endif
4071
4072     } else if ((AOP_TYPE(left) == AOP_LIT)) {
4073         lit = ulFromVal(AOP(left)->aopu.aop_lit);
4074     }
4075
4076
4077     //if(IC_TRUE(ifx) == NULL)
4078     /* if left & right are bit variables */
4079     if (AOP_TYPE(left) == AOP_CRY &&
4080         AOP_TYPE(right) == AOP_CRY ) {
4081         pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
4082         pic14_emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
4083     } else {
4084     /* subtract right from left if at the
4085     end the carry flag is set then we know that
4086         left is greater than right */
4087
4088         symbol *lbl  = newiTempLabel(NULL);
4089
4090 #ifndef _swapp
4091         if(AOP_TYPE(right) == AOP_LIT) {
4092
4093             //lit = ulFromVal(AOP(right)->aopu.aop_lit);
4094
4095             DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
4096
4097             /* special cases */
4098
4099             if(lit == 0) {
4100
4101                 if(sign != 0)
4102                     genSkipCond(&rFalseIfx,left,size-1,7);
4103                 else
4104                     /* no need to compare to 0...*/
4105                     /* NOTE: this is a de-generate compare that most certainly
4106                     *       creates some dead code. */
4107                     emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
4108
4109                 if(ifx) ifx->generated = 1;
4110                 return;
4111
4112             }
4113             size--;
4114
4115             if(size == 0) {
4116                 //i = (lit >> (size*8)) & 0xff;
4117                 DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
4118
4119                 emitpcode(POC_MOVFW, popGet(AOP(left),size));
4120
4121                 i = ((0-lit) & 0xff);
4122                 if(sign) {
4123                     if( i == 0x81) {
4124                     /* lit is 0x7f, all signed chars are less than
4125                         * this except for 0x7f itself */
4126                         emitpcode(POC_XORLW, popGetLit(0x7f));
4127                         genSkipz2(&rFalseIfx,0);
4128                     } else {
4129                         emitpcode(POC_ADDLW, popGetLit(0x80));
4130                         emitpcode(POC_ADDLW, popGetLit(i^0x80));
4131                         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4132                     }
4133
4134                 } else {
4135                     if(lit == 1) {
4136                         genSkipz2(&rFalseIfx,1);
4137                     } else {
4138                         emitpcode(POC_ADDLW, popGetLit(i));
4139                         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4140                     }
4141                 }
4142
4143                 if(ifx) ifx->generated = 1;
4144                 return;
4145             }
4146
4147             /* chars are out of the way. now do ints and longs */
4148
4149
4150             DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
4151
4152             /* special cases */
4153
4154             if(sign) {
4155
4156                 if(lit == 0) {
4157                     genSkipCond(&rFalseIfx,left,size,7);
4158                     if(ifx) ifx->generated = 1;
4159                     return;
4160                 }
4161
4162                 if(lit <0x100) {
4163                     DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
4164
4165                     //rFalseIfx.condition ^= 1;
4166                     //genSkipCond(&rFalseIfx,left,size,7);
4167                     //rFalseIfx.condition ^= 1;
4168
4169                     emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
4170                     if(rFalseIfx.condition)
4171                         emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4172                     else
4173                         emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4174
4175                     emitpcode(POC_MOVLW, popGetLit(0x100-lit));
4176                     emitpcode(POC_ADDFW, popGet(AOP(left),0));
4177                     emitpcode(POC_MOVFW, popGet(AOP(left),1));
4178
4179                     while(size > 1)
4180                         emitpcode(POC_IORFW, popGet(AOP(left),size--));
4181
4182                     if(rFalseIfx.condition) {
4183                         emitSKPZ;
4184                         emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4185
4186                     } else {
4187                         emitSKPNZ;
4188                     }
4189
4190                     genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4191                     emitpLabel(truelbl->key);
4192                     if(ifx) ifx->generated = 1;
4193                     return;
4194
4195                 }
4196
4197                 if(size == 1) {
4198
4199                     if( (lit & 0xff) == 0) {
4200                         /* lower byte is zero */
4201                         DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
4202                         i = ((lit >> 8) & 0xff) ^0x80;
4203                         emitpcode(POC_MOVFW, popGet(AOP(left),size));
4204                         emitpcode(POC_ADDLW, popGetLit( 0x80));
4205                         emitpcode(POC_ADDLW, popGetLit(0x100-i));
4206                         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4207
4208
4209                         if(ifx) ifx->generated = 1;
4210                         return;
4211
4212                     }
4213                 } else {
4214                     /* Special cases for signed longs */
4215                     if( (lit & 0xffffff) == 0) {
4216                         /* lower byte is zero */
4217                         DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
4218                         i = ((lit >> 8*3) & 0xff) ^0x80;
4219                         emitpcode(POC_MOVFW, popGet(AOP(left),size));
4220                         emitpcode(POC_ADDLW, popGetLit( 0x80));
4221                         emitpcode(POC_ADDLW, popGetLit(0x100-i));
4222                         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4223
4224
4225                         if(ifx) ifx->generated = 1;
4226                         return;
4227
4228                     }
4229
4230                 }
4231
4232
4233                 if(lit & (0x80 << (size*8))) {
4234                     /* lit is negative */
4235                     DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
4236
4237                     //genSkipCond(&rFalseIfx,left,size,7);
4238
4239                     emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
4240
4241                     if(rFalseIfx.condition)
4242                         emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4243                     else
4244                         emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4245
4246
4247                 } else {
4248                     /* lit is positive */
4249                     DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
4250                     emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
4251                     if(rFalseIfx.condition)
4252                         emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4253                     else
4254                         emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4255
4256                 }
4257
4258                 /* There are no more special cases, so perform a general compare */
4259
4260                 emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
4261                 emitpcode(POC_SUBFW, popGet(AOP(left),size));
4262
4263                 while(size--) {
4264
4265                     emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
4266                     emitSKPNZ;
4267                     emitpcode(POC_SUBFW, popGet(AOP(left),size));
4268                 }
4269                 //rFalseIfx.condition ^= 1;
4270                 genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4271
4272                 emitpLabel(truelbl->key);
4273
4274                 if(ifx) ifx->generated = 1;
4275                 return;
4276
4277
4278             }
4279
4280
4281             /* sign is out of the way. So now do an unsigned compare */
4282             DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
4283
4284
4285             /* General case - compare to an unsigned literal on the right.*/
4286
4287             i = (lit >> (size*8)) & 0xff;
4288             emitpcode(POC_MOVLW, popGetLit(i));
4289             emitpcode(POC_SUBFW, popGet(AOP(left),size));
4290             while(size--) {
4291                 i = (lit >> (size*8)) & 0xff;
4292
4293                 if(i) {
4294                     emitpcode(POC_MOVLW, popGetLit(i));
4295                     emitSKPNZ;
4296                     emitpcode(POC_SUBFW, popGet(AOP(left),size));
4297                 } else {
4298                 /* this byte of the lit is zero,
4299                     *if it's not the last then OR in the variable */
4300                     if(size)
4301                         emitpcode(POC_IORFW, popGet(AOP(left),size));
4302                 }
4303             }
4304
4305
4306         emitpLabel(lbl->key);
4307         //if(emitFinalCheck)
4308         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4309         if(sign)
4310             emitpLabel(truelbl->key);
4311
4312         if(ifx) ifx->generated = 1;
4313         return;
4314
4315
4316         }
4317 #endif  // _swapp
4318
4319         if(AOP_TYPE(left) == AOP_LIT) {
4320             //symbol *lbl = newiTempLabel(NULL);
4321
4322             //EXPERIMENTAL lit = ulFromVal(AOP(left)->aopu.aop_lit);
4323
4324
4325             DEBUGpic14_emitcode(";left lit","lit = 0x%x,sign=%d",lit,sign);
4326
4327             /* Special cases */
4328             if((lit == 0) && (sign == 0)){
4329
4330                 size--;
4331                 emitpcode(POC_MOVFW, popGet(AOP(right),size));
4332                 while(size)
4333                     emitpcode(POC_IORFW, popGet(AOP(right),--size));
4334
4335                 genSkipz2(&rFalseIfx,0);
4336                 if(ifx) ifx->generated = 1;
4337                 return;
4338             }
4339
4340             if(size==1) {
4341                 /* Special cases */
4342                 lit &= 0xff;
4343                 if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
4344                     /* degenerate compare can never be true */
4345                     if(rFalseIfx.condition == 0)
4346                         emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
4347
4348                     if(ifx) ifx->generated = 1;
4349                     return;
4350                 }
4351
4352                 if(sign) {
4353                     /* signed comparisons to a literal byte */
4354
4355                     int lp1 = (lit+1) & 0xff;
4356
4357                     DEBUGpic14_emitcode(";left lit","line = %d lit = 0x%x",__LINE__,lit);
4358                     switch (lp1) {
4359                     case 0:
4360                         rFalseIfx.condition ^= 1;
4361                         genSkipCond(&rFalseIfx,right,0,7);
4362                         break;
4363                     case 0x7f:
4364                         emitpcode(POC_MOVFW, popGet(AOP(right),0));
4365                         emitpcode(POC_XORLW, popGetLit(0x7f));
4366                         genSkipz2(&rFalseIfx,1);
4367                         break;
4368                     default:
4369                         emitpcode(POC_MOVFW, popGet(AOP(right),0));
4370                         emitpcode(POC_ADDLW, popGetLit(0x80));
4371                         emitpcode(POC_ADDLW, popGetLit(((0-(lit+1)) & 0xff) ^ 0x80));
4372                         rFalseIfx.condition ^= 1;
4373                         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4374                         break;
4375                     }
4376                     if(ifx) ifx->generated = 1;
4377                 } else {
4378                     /* unsigned comparisons to a literal byte */
4379
4380                     switch(lit & 0xff ) {
4381                     case 0:
4382                         emitpcode(POC_MOVFW, popGet(AOP(right),0));
4383                         genSkipz2(&rFalseIfx,0);
4384                         if(ifx) ifx->generated = 1;
4385                         break;
4386                     case 0x7f:
4387                         genSkipCond(&rFalseIfx,right,0,7);
4388                         if(ifx) ifx->generated = 1;
4389                         break;
4390
4391                     default:
4392                         emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
4393                         emitpcode(POC_SUBFW, popGet(AOP(right),0));
4394                         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4395                         rFalseIfx.condition ^= 1;
4396                         if (AOP_TYPE(result) == AOP_CRY) {
4397                             genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4398                             if(ifx) ifx->generated = 1;
4399                         } else {
4400                             DEBUGpic14_emitcode ("; ***","%s  %d RFIfx.cond=%d",__FUNCTION__,__LINE__, rFalseIfx.condition);
4401                             emitpcode(POC_CLRF, popGet(AOP(result),0));
4402                             emitpcode(POC_RLF, popGet(AOP(result),0));
4403                             emitpcode(POC_MOVLW, popGetLit(0x01));
4404                             emitpcode(POC_XORWF, popGet(AOP(result),0));
4405                         }
4406                         break;
4407                     }
4408                 }
4409
4410                 //goto check_carry;
4411                 return;
4412
4413             } else {
4414
4415                 /* Size is greater than 1 */
4416
4417                 if(sign) {
4418                     int lp1 = lit+1;
4419
4420                     size--;
4421
4422                     if(lp1 == 0) {
4423                         /* this means lit = 0xffffffff, or -1 */
4424
4425
4426                         DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
4427                         rFalseIfx.condition ^= 1;
4428                         genSkipCond(&rFalseIfx,right,size,7);
4429                         if(ifx) ifx->generated = 1;
4430                         return;
4431                     }
4432
4433                     if(lit == 0) {
4434                         int s = size;
4435
4436                         if(rFalseIfx.condition) {
4437                             emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
4438                             emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4439                         }
4440
4441                         emitpcode(POC_MOVFW, popGet(AOP(right),size));
4442                         while(size--)
4443                             emitpcode(POC_IORFW, popGet(AOP(right),size));
4444
4445
4446                         emitSKPZ;
4447                         if(rFalseIfx.condition) {
4448                             emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4449                             emitpLabel(truelbl->key);
4450                         }else {
4451                             rFalseIfx.condition ^= 1;
4452                             genSkipCond(&rFalseIfx,right,s,7);
4453                         }
4454
4455                         if(ifx) ifx->generated = 1;
4456                         return;
4457                     }
4458
4459                     if((size == 1) &&  (0 == (lp1&0xff))) {
4460                         /* lower byte of signed word is zero */
4461                         DEBUGpic14_emitcode(";left lit","line = %d  0x%x+1 low byte is zero",__LINE__,lit);
4462                         i = ((lp1 >> 8) & 0xff) ^0x80;
4463                         emitpcode(POC_MOVFW, popGet(AOP(right),size));
4464                         emitpcode(POC_ADDLW, popGetLit( 0x80));
4465                         emitpcode(POC_ADDLW, popGetLit(0x100-i));
4466                         rFalseIfx.condition ^= 1;
4467                         genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4468
4469
4470                         if(ifx) ifx->generated = 1;
4471                         return;
4472                     }
4473
4474                     if(lit & (0x80 << (size*8))) {
4475                         /* Lit is less than zero */
4476                         DEBUGpic14_emitcode(";left lit","line = %d  0x%x is less than 0",__LINE__,lit);
4477                         //rFalseIfx.condition ^= 1;
4478                         //genSkipCond(&rFalseIfx,left,size,7);
4479                         //rFalseIfx.condition ^= 1;
4480                         emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
4481                         //emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4482
4483                         if(rFalseIfx.condition)
4484                             emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4485                         else
4486                             emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4487
4488
4489                     } else {
4490                         /* Lit is greater than or equal to zero */
4491                         DEBUGpic14_emitcode(";left lit","line = %d  0x%x is greater than 0",__LINE__,lit);
4492                         //rFalseIfx.condition ^= 1;
4493                         //genSkipCond(&rFalseIfx,right,size,7);
4494                         //rFalseIfx.condition ^= 1;
4495
4496                         //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
4497                         //emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4498
4499                         emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
4500                         if(rFalseIfx.condition)
4501                             emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4502                         else
4503                             emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4504
4505                     }
4506
4507
4508                     emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
4509                     emitpcode(POC_SUBFW, popGet(AOP(right),size));
4510
4511                     while(size--) {
4512
4513                         emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
4514                         emitSKPNZ;
4515                         emitpcode(POC_SUBFW, popGet(AOP(right),size));
4516                     }
4517                     rFalseIfx.condition ^= 1;
4518                     //rFalseIfx.condition = 1;
4519                     genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4520
4521                     emitpLabel(truelbl->key);
4522
4523                     if(ifx) ifx->generated = 1;
4524                     return;
4525                     // end of if (sign)
4526                 } else {
4527
4528                     /* compare word or long to an unsigned literal on the right.*/
4529
4530
4531                     size--;
4532                     if(lit < 0xff) {
4533                         DEBUGpic14_emitcode ("; ***","%s  %d lit =0x%x < 0xff",__FUNCTION__,__LINE__,lit);
4534                         switch (lit) {
4535                         case 0:
4536                             break; /* handled above */
4537                         /*
4538                         case 0xff:
4539                             emitpcode(POC_MOVFW, popGet(AOP(right),size));
4540                             while(size--)
4541                                 emitpcode(POC_IORFW, popGet(AOP(right),size));
4542                             genSkipz2(&rFalseIfx,0);
4543                             break;
4544                         */
4545                         default:
4546                             emitpcode(POC_MOVFW, popGet(AOP(right),size));
4547                             while(--size)
4548                                 emitpcode(POC_IORFW, popGet(AOP(right),size));
4549
4550                             emitSKPZ;
4551                             if(rFalseIfx.condition)
4552                                 emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
4553                             else
4554                                 emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
4555
4556
4557                             emitpcode(POC_MOVLW, popGetLit(lit+1));
4558                             emitpcode(POC_SUBFW, popGet(AOP(right),0));
4559
4560                             rFalseIfx.condition ^= 1;
4561                             genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4562                         }
4563
4564                         emitpLabel(truelbl->key);
4565
4566                         if(ifx) ifx->generated = 1;
4567                         return;
4568                     }
4569
4570
4571                     lit++;
4572                     DEBUGpic14_emitcode ("; ***","%s  %d lit =0x%x",__FUNCTION__,__LINE__,lit);
4573                     i = (lit >> (size*8)) & 0xff;
4574
4575                     emitpcode(POC_MOVLW, popGetLit(i));
4576                     emitpcode(POC_SUBFW, popGet(AOP(right),size));
4577
4578                     while(size--) {
4579                         i = (lit >> (size*8)) & 0xff;
4580
4581                         if(i) {
4582                             emitpcode(POC_MOVLW, popGetLit(i));
4583                             emitSKPNZ;
4584                             emitpcode(POC_SUBFW, popGet(AOP(right),size));
4585                         } else {
4586                         /* this byte of the lit is zero,
4587                             *if it's not the last then OR in the variable */
4588                             if(size)
4589                                 emitpcode(POC_IORFW, popGet(AOP(right),size));
4590                         }
4591                     }
4592
4593
4594                     emitpLabel(lbl->key);
4595
4596                     rFalseIfx.condition ^= 1;
4597                     genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4598                 }
4599
4600                 if(sign)
4601                     emitpLabel(truelbl->key);
4602                 if(ifx) ifx->generated = 1;
4603                 return;
4604             }
4605         }
4606         /* Compare two variables */
4607
4608         DEBUGpic14_emitcode(";sign","%d",sign);
4609
4610         size--;
4611         if(sign) {
4612             /* Sigh. thus sucks... */
4613             if(size) {
4614                 emitpcode(POC_MOVFW, popGet(AOP(left),size));
4615                 emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
4616                 emitpcode(POC_MOVLW, popGetLit(0x80));
4617                 emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
4618                 emitpcode(POC_XORFW, popGet(AOP(right),size));
4619                 emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
4620             } else {
4621                 /* Signed char comparison */
4622                 /* Special thanks to Nikolai Golovchenko for this snippet */
4623                 emitpcode(POC_MOVFW, popGet(AOP(right),0));
4624                 emitpcode(POC_SUBFW, popGet(AOP(left),0));
4625                 emitpcode(POC_RRFW,  popGet(AOP(left),0)); /* could be any register */
4626                 emitpcode(POC_XORFW, popGet(AOP(left),0));
4627                 emitpcode(POC_XORFW, popGet(AOP(right),0));
4628                 emitpcode(POC_ADDLW, popGetLit(0x80));
4629
4630                 DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4631                 genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4632
4633                 if(ifx) ifx->generated = 1;
4634                 return;
4635             }
4636
4637         } else {
4638
4639             emitpcode(POC_MOVFW, popGet(AOP(right),size));
4640             emitpcode(POC_SUBFW, popGet(AOP(left),size));
4641         }
4642
4643
4644         /* The rest of the bytes of a multi-byte compare */
4645         while (size) {
4646
4647             emitSKPZ;
4648             emitpcode(POC_GOTO,  popGetLabel(lbl->key));
4649             size--;
4650
4651             emitpcode(POC_MOVFW, popGet(AOP(right),size));
4652             emitpcode(POC_SUBFW, popGet(AOP(left),size));
4653
4654
4655         }
4656
4657         emitpLabel(lbl->key);
4658
4659         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4660         if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) ||
4661             (AOP_TYPE(result) == AOP_REG)) {
4662             emitpcode(POC_CLRF, popGet(AOP(result),0));
4663             emitpcode(POC_RLF, popGet(AOP(result),0));
4664         } else {
4665             genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4666         }
4667         //genSkipc(&rFalseIfx); assert ( !"genSkipc should have inverse logic" );
4668         if(ifx) ifx->generated = 1;
4669
4670         return;
4671
4672     }
4673
4674     // check_carry:
4675     if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
4676         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4677         pic14_outBitC(result);
4678     } else {
4679         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4680         /* if the result is used in the next
4681         ifx conditional branch then generate
4682         code a little differently */
4683         if (ifx )
4684             genIfxJump (ifx,"c");
4685         else
4686             pic14_outBitC(result);
4687         /* leave the result in acc */
4688     }
4689
4690 }
4691 #endif
4692
4693 /*-----------------------------------------------------------------*/
4694 /* genCmpGt :- greater than comparison                             */
4695 /*-----------------------------------------------------------------*/
4696 static void genCmpGt (iCode *ic, iCode *ifx)
4697 {
4698     operand *left, *right, *result;
4699     sym_link *letype , *retype;
4700     int sign ;
4701
4702     FENTRY;
4703     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4704     left = IC_LEFT(ic);
4705     right= IC_RIGHT(ic);
4706     result = IC_RESULT(ic);
4707
4708     letype = getSpec(operandType(left));
4709     retype =getSpec(operandType(right));
4710     sign =  !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
4711     /* assign the amsops */
4712     aopOp (left,ic,FALSE);
4713     aopOp (right,ic,FALSE);
4714     aopOp (result,ic,TRUE);
4715
4716     genCmp(right, left, result, ifx, sign);
4717
4718     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4719     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4720     freeAsmop(result,NULL,ic,TRUE);
4721 }
4722
4723 /*-----------------------------------------------------------------*/
4724 /* genCmpLt - less than comparisons                                */
4725 /*-----------------------------------------------------------------*/
4726 static void genCmpLt (iCode *ic, iCode *ifx)
4727 {
4728     operand *left, *right, *result;
4729     sym_link *letype , *retype;
4730     int sign ;
4731
4732     FENTRY;
4733     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4734     left = IC_LEFT(ic);
4735     right= IC_RIGHT(ic);
4736     result = IC_RESULT(ic);
4737
4738     letype = getSpec(operandType(left));
4739     retype =getSpec(operandType(right));
4740     sign =  !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
4741
4742     /* assign the amsops */
4743     aopOp (left,ic,FALSE);
4744     aopOp (right,ic,FALSE);
4745     aopOp (result,ic,TRUE);
4746
4747     genCmp(left, right, result, ifx, sign);
4748
4749     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4750     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4751     freeAsmop(result,NULL,ic,TRUE);
4752 }
4753
4754 #if 0
4755 /*-----------------------------------------------------------------*/
4756 /* genc16bit2lit - compare a 16 bit value to a literal             */
4757 /*-----------------------------------------------------------------*/
4758 static void genc16bit2lit(operand *op, int lit, int offset)
4759 {
4760     int i;
4761
4762     FENTRY;
4763     DEBUGpic14_emitcode ("; ***","%s  %d, lit = %d",__FUNCTION__,__LINE__,lit);
4764     if( (lit&0xff) == 0)
4765         i=1;
4766     else
4767         i=0;
4768
4769     switch( BYTEofLONG(lit,i)) {
4770     case 0:
4771         emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
4772         break;
4773     case 1:
4774         emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
4775         break;
4776     case 0xff:
4777         emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
4778         break;
4779     default:
4780         emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
4781         emitpcode(POC_XORLW,popGetLit(BYTEofLONG(lit,i)));
4782     }
4783
4784     i ^= 1;
4785
4786     switch( BYTEofLONG(lit,i)) {
4787     case 0:
4788         emitpcode(POC_IORFW,popGet(AOP(op),offset+i));
4789         break;
4790     case 1:
4791         emitSKPNZ;
4792         emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
4793         break;
4794     case 0xff:
4795         emitSKPNZ;
4796         emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
4797         break;
4798     default:
4799         emitpcode(POC_MOVLW,popGetLit(BYTEofLONG(lit,i)));
4800         emitSKPNZ;
4801         emitpcode(POC_XORFW,popGet(AOP(op),offset+i));
4802
4803     }
4804
4805 }
4806 #endif
4807
4808 #if 0
4809 /*-----------------------------------------------------------------*/
4810 /* gencjneshort - compare and jump if not equal                    */
4811 /*-----------------------------------------------------------------*/
4812 static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
4813 {
4814     int size = min(AOP_SIZE(left),AOP_SIZE(right));
4815     int offset = 0;
4816     //resolvedIfx rIfx;
4817     symbol *lbl;
4818
4819     //unsigned long lit = 0L;
4820     FENTRY;
4821     if (!ifx && (!result || AOP_TYPE(result) == AOP_CRY)) {
4822       emitpComment ("gencjne: no ifx, no (real) result -- comparison ignored");
4823       return;
4824     }
4825     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
4826     DEBUGpic14_AopType(__LINE__,left,right,result);
4827
4828     assert (!pic14_sameRegs (AOP(left), AOP(result)));
4829     assert (!pic14_sameRegs (AOP(right), AOP(result)));
4830     if (AOP_SIZE(result)) {
4831       for (offset = 0; offset < AOP_SIZE(result); offset++)
4832         emitpcode (POC_CLRF, popGet (AOP(result), offset));
4833     }
4834
4835     assert (AOP_SIZE(left) == AOP_SIZE(right));
4836     //resolveIfx(&rIfx,ifx);
4837     lbl = newiTempLabel (NULL);
4838     while (size--)
4839     {
4840       mov2w (AOP(right),size);
4841       emitpcode (POC_XORFW, popGet (AOP(left), size));
4842       if (size)
4843       {
4844         emitSKPZ;
4845         emitpcode (POC_GOTO, popGetLabel (lbl->key));
4846       }
4847     } // while
4848     emitpLabel (lbl->key);
4849     if (AOP_SIZE(result)) {
4850       emitSKPNZ;
4851       emitpcode (POC_INCF, popGet (AOP(result), 0));
4852     } else {
4853       assert (ifx);
4854       genSkipz (ifx, NULL != IC_TRUE(ifx));
4855       ifx->generated = 1;
4856     }
4857     return;
4858 #if 0
4859     if(result)
4860     {
4861         DEBUGpic14_emitcode ("; ***","%s  %d result is not null",__FUNCTION__,__LINE__);
4862         assert (!pic14_sameRegs (AOP(result), AOP(left)));
4863         assert (!pic14_sameRegs (AOP(result), AOP(right)));
4864         for (offset=0; offset < AOP_SIZE(result); offset++)
4865         {
4866             emitpcode (POC_CLRF, popGet (AOP(result), offset));
4867         } // for offset
4868     }
4869
4870
4871     /* if the left side is a literal or
4872     if the right is in a pointer register and left
4873     is not */
4874     if ((AOP_TYPE(left) == AOP_LIT) ||
4875         (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
4876         operand *t = right;
4877         right = left;
4878         left = t;
4879     }
4880     if(AOP_TYPE(right) == AOP_LIT)
4881         lit = ulFromVal(AOP(right)->aopu.aop_lit);
4882
4883     /* if the right side is a literal then anything goes */
4884     if (AOP_TYPE(right) == AOP_LIT &&
4885         AOP_TYPE(left) != AOP_DIR ) {
4886         switch(size) {
4887         case 2:
4888             genc16bit2lit(left, lit, 0);
4889             emitSKPNZ;
4890             emitpcode(POC_GOTO,popGetLabel(lbl->key));
4891             break;
4892         default:
4893             offset = 0;
4894             while (size--) {
4895                 if(lit & 0xff) {
4896                     emitpcode(POC_MOVFW,popGet(AOP(left),offset));
4897                     emitpcode(POC_XORLW,popGetLit(lit & 0xff));
4898                 } else {
4899                     emitpcode(POC_MOVF,popGet(AOP(left),offset));
4900                 }
4901
4902                 emitSKPNZ;
4903                 emitpcode(POC_GOTO,popGetLabel(lbl->key));
4904                 offset++;
4905                 lit >>= 8;
4906             }
4907             break;
4908         }
4909     }
4910
4911     /* if the right side is in a register or in direct space or
4912     if the left is a pointer register & right is not */
4913     else if (AOP_TYPE(right) == AOP_REG ||
4914         AOP_TYPE(right) == AOP_DIR ||
4915         (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
4916         (IS_AOP_PREG(left) && !IS_AOP_PREG(right))) {
4917         //int lbl_key = (rIfx.condition) ? rIfx.lbl->key : lbl->key;
4918         int lbl_key = lbl->key;
4919
4920         if(!result) {
4921             DEBUGpic14_emitcode ("; ***","%s  %d -- ERROR",__FUNCTION__,__LINE__);
4922             fprintf(stderr, "%s  %d error - expecting result to be non_null\n",
4923                 __FUNCTION__,__LINE__);
4924             return;
4925         }
4926
4927         /*     switch(size) { */
4928         /*     case 2: */
4929         /*       genc16bit2lit(left, lit, 0); */
4930         /*       emitSKPNZ; */
4931         /*       emitpcode(POC_GOTO,popGetLabel(lbl->key)); */
4932         /*       break; */
4933         /*     default: */
4934         offset = 0;
4935         while (size--) {
4936             int emit_skip=1;
4937             if((AOP_TYPE(left) == AOP_DIR) &&
4938                 ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
4939
4940                 emitpcode(POC_MOVFW,popGet(AOP(left),offset));
4941                 emitpcode(POC_XORFW,popGet(AOP(right),offset));
4942
4943             } else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
4944
4945                 switch (lit & 0xff) {
4946                 case 0:
4947                     emitpcode(POC_MOVFW,popGet(AOP(left),offset));
4948                     break;
4949                 case 1:
4950                     emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
4951                     //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
4952                     emitpcode(POC_GOTO,popGetLabel(lbl->key));
4953                     emit_skip=0;
4954                     break;
4955                 case 0xff:
4956                     emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
4957                     //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
4958                     //emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
4959                     emitpcode(POC_GOTO,popGetLabel(lbl_key));
4960                     emit_skip=0;
4961                     break;
4962                 default:
4963                     emitpcode(POC_MOVFW,popGet(AOP(left),offset));
4964                     emitpcode(POC_XORLW,popGetLit(lit & 0xff));
4965                 }
4966                 lit >>= 8;
4967
4968             } else {
4969                 emitpcode(POC_MOVF,popGet(AOP(left),offset));
4970             }
4971             if(emit_skip) {
4972                 if(AOP_TYPE(result) == AOP_CRY) {
4973                     pic14_emitcode(";***","%s  %d",__FUNCTION__,__LINE__);
4974                     if(rIfx.condition)
4975                         emitSKPNZ;
4976                     else
4977                         emitSKPZ;
4978                     emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
4979                 } else {
4980                     /* fix me. probably need to check result size too */
4981                     //emitpcode(POC_CLRF,popGet(AOP(result),0));
4982                     if(rIfx.condition)
4983                         emitSKPZ;
4984                     else
4985                         emitSKPNZ;
4986                     emitpcode(POC_GOTO,popGetLabel(lbl_key));
4987                 }
4988                 if(ifx)
4989                     ifx->generated=1;
4990             }
4991             emit_skip++;
4992             offset++;
4993         }
4994         /*       break; */
4995         /*     } */
4996     } else if(AOP_TYPE(right) == AOP_REG &&
4997         AOP_TYPE(left) != AOP_DIR){
4998
4999         offset = 0;
5000         while(size--) {
5001             emitpcode(POC_MOVFW,popGet(AOP(left),offset));
5002             emitpcode(POC_XORFW,popGet(AOP(right),offset));
5003             pic14_emitcode(";***","%s  %d",__FUNCTION__,__LINE__);
5004             if(rIfx.condition)
5005                 emitSKPNZ;
5006             else
5007                 emitSKPZ;
5008             emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
5009             offset++;
5010         }
5011
5012     }else{
5013         /* right is a pointer reg need both a & b */
5014         offset = 0;
5015         while(size--) {
5016             char *l = aopGet(AOP(left),offset,FALSE,FALSE);
5017             if(strcmp(l,"b"))
5018                 pic14_emitcode("mov","b,%s",l);
5019             MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
5020             pic14_emitcode("cjne","a,b,%05d_DS_",lbl->key+100);
5021             offset++;
5022         }
5023     }
5024
5025     emitpcode(POC_INCF,popGet(AOP(result),0));
5026     if(!rIfx.condition)
5027         emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
5028
5029     emitpLabel(lbl->key);
5030
5031     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5032
5033     if(ifx)
5034         ifx->generated = 1;
5035 #endif
5036 }
5037 #endif
5038
5039 #if 0
5040 /*-----------------------------------------------------------------*/
5041 /* gencjne - compare and jump if not equal                         */
5042 /*-----------------------------------------------------------------*/
5043 static void gencjne(operand *left, operand *right, iCode *ifx)
5044 {
5045     symbol *tlbl  = newiTempLabel(NULL);
5046
5047     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5048     gencjneshort(left, right, lbl);
5049
5050     pic14_emitcode("mov","a,%s",one);
5051     pic14_emitcode("sjmp","%05d_DS_",tlbl->key+100);
5052     pic14_emitcode("","%05d_DS_:",lbl->key+100);
5053     pic14_emitcode("clr","a");
5054     pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5055
5056     emitpLabel(lbl->key);
5057     emitpLabel(tlbl->key);
5058
5059 }
5060 #endif
5061
5062 /*-----------------------------------------------------------------*/
5063 /* genCmpEq - generates code for equal to                          */
5064 /*-----------------------------------------------------------------*/
5065 static void genCmpEq (iCode *ic, iCode *ifx)
5066 {
5067   operand *left, *right, *result;
5068   int size;
5069   symbol *false_label;
5070
5071   FENTRY;
5072   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5073
5074   if(ifx)
5075     DEBUGpic14_emitcode ("; ifx is non-null","");
5076   else
5077     DEBUGpic14_emitcode ("; ifx is null","");
5078
5079   aopOp((left=IC_LEFT(ic)),ic,FALSE);
5080   aopOp((right=IC_RIGHT(ic)),ic,FALSE);
5081   aopOp((result=IC_RESULT(ic)),ic,TRUE);
5082
5083   DEBUGpic14_AopType(__LINE__,left,right,result);
5084
5085   /* if literal, move literal to right */
5086   if (op_isLitLike (IC_LEFT(ic))) {
5087     operand *tmp = right ;
5088     right = left;
5089     left = tmp;
5090   }
5091
5092   false_label = NULL;
5093   if (ifx && !IC_TRUE(ifx))
5094   {
5095     assert (IC_FALSE(ifx));
5096     false_label = IC_FALSE(ifx);
5097   }
5098
5099   size = min(AOP_SIZE(left),AOP_SIZE(right));
5100   assert(!pic14_sameRegs(AOP(result),AOP(left)));
5101   assert(!pic14_sameRegs(AOP(result),AOP(right)));
5102
5103   /* assume left != right */
5104   {
5105     int i;
5106     for (i=0; i < AOP_SIZE(result); i++)
5107     {
5108       emitpcode(POC_CLRF, popGet(AOP(result),i));
5109     }
5110   }
5111
5112   if (AOP_TYPE(right) == AOP_LIT)
5113   {
5114     unsigned long lit = ulFromVal (AOP(right)->aopu.aop_lit);
5115     int i;
5116     size = AOP_SIZE(left);
5117     assert(!op_isLitLike(left));
5118
5119     switch (lit)
5120     {
5121       case 0:
5122         mov2w(AOP(left), 0);
5123     for (i=1; i < size; i++)
5124       emitpcode(POC_IORFW,popGet(AOP(left),i));
5125     /* now Z is set iff `left == right' */
5126     emitSKPZ;
5127     if (!false_label) false_label = newiTempLabel(NULL);
5128     emitpcode(POC_GOTO, popGetLabel(false_label->key));
5129     break;
5130
5131       default:
5132     for (i=0; i < size; i++)
5133     {
5134       mov2w(AOP(left),i);
5135       emitpcode(POC_XORLW, popGetLit(lit >> (8*i)));
5136       /* now Z is cleared if `left != right' */
5137       emitSKPZ;
5138       if (!false_label) false_label = newiTempLabel(NULL);
5139       emitpcode(POC_GOTO, popGetLabel(false_label->key));
5140     } // for i
5141     break;
5142     } // switch (lit)
5143   }
5144   else
5145   {
5146     /* right is no literal */
5147     int i;
5148
5149     for (i=0; i < size; i++)
5150     {
5151       mov2w(AOP(right),i);
5152       emitpcode(POC_XORFW,popGet(AOP(left),i));
5153       /* now Z is cleared if `left != right' */
5154       emitSKPZ;
5155       if (!false_label) false_label = newiTempLabel(NULL);
5156       emitpcode(POC_GOTO, popGetLabel(false_label->key));
5157     } // for i
5158   }
5159
5160   /* if we reach here, left == right */
5161
5162   if (AOP_SIZE(result) > 0)
5163   {
5164     emitpcode(POC_INCF, popGet(AOP(result),0));
5165   }
5166
5167   if (ifx && IC_TRUE(ifx))
5168   {
5169     emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
5170   }
5171
5172   if (false_label && (!ifx || IC_TRUE(ifx)))
5173     emitpLabel(false_label->key);
5174
5175   if (ifx) ifx->generated = 1;
5176
5177   freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5178   freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5179   freeAsmop(result,NULL,ic,TRUE);
5180 }
5181
5182 /*-----------------------------------------------------------------*/
5183 /* ifxForOp - returns the icode containing the ifx for operand     */
5184 /*-----------------------------------------------------------------*/
5185 static iCode *ifxForOp ( operand *op, iCode *ic )
5186 {
5187     FENTRY;
5188     /* if true symbol then needs to be assigned */
5189     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5190     if (IS_TRUE_SYMOP(op))
5191         return NULL ;
5192
5193     /* if this has register type condition and
5194     the next instruction is ifx with the same operand
5195     and live to of the operand is upto the ifx only then */
5196     if (ic->next &&
5197         ic->next->op == IFX &&
5198         IC_COND(ic->next)->key == op->key &&
5199         OP_SYMBOL(op)->liveTo <= ic->next->seq )
5200         return ic->next;
5201
5202     if (ic->next &&
5203         ic->next->op == IFX &&
5204         IC_COND(ic->next)->key == op->key) {
5205         DEBUGpic14_emitcode ("; WARNING ","%d IGNORING liveTo range in %s",__LINE__,__FUNCTION__);
5206         return ic->next;
5207     }
5208
5209     DEBUGpic14_emitcode ("; NULL :(","%d",__LINE__);
5210     if (ic->next &&
5211         ic->next->op == IFX)
5212         DEBUGpic14_emitcode ("; ic-next"," is an IFX");
5213
5214     if (ic->next &&
5215         ic->next->op == IFX &&
5216         IC_COND(ic->next)->key == op->key) {
5217         DEBUGpic14_emitcode ("; "," key is okay");
5218         DEBUGpic14_emitcode ("; "," key liveTo %d, next->seq = %d",
5219             OP_SYMBOL(op)->liveTo,
5220             ic->next->seq);
5221     }
5222
5223
5224     return NULL;
5225 }
5226 /*-----------------------------------------------------------------*/
5227 /* genAndOp - for && operation                                     */
5228 /*-----------------------------------------------------------------*/
5229 static void genAndOp (iCode *ic)
5230 {
5231     operand *left,*right, *result;
5232     /*     symbol *tlbl; */
5233
5234     FENTRY;
5235     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5236     /* note here that && operations that are in an
5237     if statement are taken away by backPatchLabels
5238     only those used in arthmetic operations remain */
5239     aopOp((left=IC_LEFT(ic)),ic,FALSE);
5240     aopOp((right=IC_RIGHT(ic)),ic,FALSE);
5241     aopOp((result=IC_RESULT(ic)),ic,FALSE);
5242
5243     DEBUGpic14_AopType(__LINE__,left,right,result);
5244
5245     emitpcode(POC_MOVFW,popGet(AOP(left),0));
5246     emitpcode(POC_ANDFW,popGet(AOP(right),0));
5247     emitpcode(POC_MOVWF,popGet(AOP(result),0));
5248
5249     /* if both are bit variables */
5250     /*     if (AOP_TYPE(left) == AOP_CRY && */
5251     /*         AOP_TYPE(right) == AOP_CRY ) { */
5252     /*         pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
5253     /*         pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
5254     /*         pic14_outBitC(result); */
5255     /*     } else { */
5256     /*         tlbl = newiTempLabel(NULL); */
5257     /*         pic14_toBoolean(left);     */
5258     /*         pic14_emitcode("jz","%05d_DS_",tlbl->key+100); */
5259     /*         pic14_toBoolean(right); */
5260     /*         pic14_emitcode("","%05d_DS_:",tlbl->key+100); */
5261     /*         pic14_outBitAcc(result); */
5262     /*     } */
5263
5264     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5265     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5266     freeAsmop(result,NULL,ic,TRUE);
5267 }
5268
5269
5270 /*-----------------------------------------------------------------*/
5271 /* genOrOp - for || operation                                      */
5272 /*-----------------------------------------------------------------*/
5273 /*
5274 tsd pic port -
5275 modified this code, but it doesn't appear to ever get called
5276 */
5277
5278 static void genOrOp (iCode *ic)
5279 {
5280     operand *left,*right, *result;
5281     symbol *tlbl;
5282     int i;
5283
5284     /* note here that || operations that are in an
5285     if statement are taken away by backPatchLabels
5286     only those used in arthmetic operations remain */
5287     FENTRY;
5288     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5289     aopOp((left=IC_LEFT(ic)),ic,FALSE);
5290     aopOp((right=IC_RIGHT(ic)),ic,FALSE);
5291     aopOp((result=IC_RESULT(ic)),ic,FALSE);
5292
5293     DEBUGpic14_AopType(__LINE__,left,right,result);
5294
5295     for (i=0; i < AOP_SIZE(result); i++)
5296     {
5297         emitpcode(POC_CLRF, popGet(AOP(result), i));
5298     } // for i
5299
5300     tlbl = newiTempLabel(NULL);
5301     pic14_toBoolean(left);
5302     emitSKPZ;
5303     emitpcode(POC_GOTO, popGetLabel(tlbl->key));
5304     pic14_toBoolean(right);
5305     emitpLabel(tlbl->key);
5306     /* here Z is clear IFF `left || right' */
5307     emitSKPZ;
5308     emitpcode(POC_INCF, popGet(AOP(result), 0));
5309
5310     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5311     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5312     freeAsmop(result,NULL,ic,TRUE);
5313 }
5314
5315 /*-----------------------------------------------------------------*/
5316 /* isLiteralBit - test if lit == 2^n                               */
5317 /*-----------------------------------------------------------------*/
5318 static int isLiteralBit(unsigned long lit)
5319 {
5320     unsigned long pw[32] = {1L,2L,4L,8L,16L,32L,64L,128L,
5321         0x100L,0x200L,0x400L,0x800L,
5322         0x1000L,0x2000L,0x4000L,0x8000L,
5323         0x10000L,0x20000L,0x40000L,0x80000L,
5324         0x100000L,0x200000L,0x400000L,0x800000L,
5325         0x1000000L,0x2000000L,0x4000000L,0x8000000L,
5326         0x10000000L,0x20000000L,0x40000000L,0x80000000L};
5327     int idx;
5328
5329     FENTRY;
5330     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5331     for(idx = 0; idx < 32; idx++)
5332         if(lit == pw[idx])
5333             return idx+1;
5334         return 0;
5335 }
5336
5337 /*-----------------------------------------------------------------*/
5338 /* continueIfTrue -                                                */
5339 /*-----------------------------------------------------------------*/
5340 static void continueIfTrue (iCode *ic)
5341 {
5342     FENTRY;
5343     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5344     if(IC_TRUE(ic))
5345     {
5346         // Why +100?!?
5347         emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key+100));
5348         pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
5349     }
5350     ic->generated = 1;
5351 }
5352
5353 /*-----------------------------------------------------------------*/
5354 /* jmpIfTrue -                                                     */
5355 /*-----------------------------------------------------------------*/
5356 static void jumpIfTrue (iCode *ic)
5357 {
5358     FENTRY;
5359     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5360     if(!IC_TRUE(ic))
5361     {
5362         // Why +100?!?
5363         emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key+100));
5364         pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
5365     }
5366     ic->generated = 1;
5367 }
5368
5369 /*-----------------------------------------------------------------*/
5370 /* jmpTrueOrFalse -                                                */
5371 /*-----------------------------------------------------------------*/
5372 static void jmpTrueOrFalse (iCode *ic, symbol *tlbl)
5373 {
5374     FENTRY;
5375     // ugly but optimized by peephole
5376     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5377     if(IC_TRUE(ic)){
5378         symbol *nlbl = newiTempLabel(NULL);
5379         pic14_emitcode("sjmp","%05d_DS_",nlbl->key+100);
5380         pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5381         pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
5382         pic14_emitcode("","%05d_DS_:",nlbl->key+100);
5383     }
5384     else{
5385         pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
5386         pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5387     }
5388     ic->generated = 1;
5389 }
5390
5391 /*-----------------------------------------------------------------*/
5392 /* genAnd  - code for and                                          */
5393 /*-----------------------------------------------------------------*/
5394 static void genAnd (iCode *ic, iCode *ifx)
5395 {
5396     operand *left, *right, *result;
5397     int size, offset=0;
5398     unsigned long lit = 0L;
5399     int bytelit = 0;
5400     resolvedIfx rIfx;
5401
5402     FENTRY;
5403     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5404     aopOp((left = IC_LEFT(ic)),ic,FALSE);
5405     aopOp((right= IC_RIGHT(ic)),ic,FALSE);
5406     aopOp((result=IC_RESULT(ic)),ic,TRUE);
5407
5408     resolveIfx(&rIfx,ifx);
5409
5410     /* if left is a literal & right is not then exchange them */
5411     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
5412         AOP_NEEDSACC(left)) {
5413         operand *tmp = right ;
5414         right = left;
5415         left = tmp;
5416     }
5417
5418     /* if result = right then exchange them */
5419     if(pic14_sameRegs(AOP(result),AOP(right))){
5420         operand *tmp = right ;
5421         right = left;
5422         left = tmp;
5423     }
5424
5425     /* if right is bit then exchange them */
5426     if (AOP_TYPE(right) == AOP_CRY &&
5427         AOP_TYPE(left) != AOP_CRY){
5428         operand *tmp = right ;
5429         right = left;
5430         left = tmp;
5431     }
5432     if(AOP_TYPE(right) == AOP_LIT)
5433         lit = ulFromVal (AOP(right)->aopu.aop_lit);
5434
5435     size = AOP_SIZE(result);
5436
5437     DEBUGpic14_AopType(__LINE__,left,right,result);
5438
5439     // if(bit & yy)
5440     // result = bit & yy;
5441     if (AOP_TYPE(left) == AOP_CRY){
5442         // c = bit & literal;
5443         if(AOP_TYPE(right) == AOP_LIT){
5444             if(lit & 1) {
5445                 if(size && pic14_sameRegs(AOP(result),AOP(left)))
5446                     // no change
5447                     goto release;
5448                 pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
5449             } else {
5450                 // bit(result) = 0;
5451                 if(size && (AOP_TYPE(result) == AOP_CRY)){
5452                     pic14_emitcode("clr","%s",AOP(result)->aopu.aop_dir);
5453                     goto release;
5454                 }
5455                 if((AOP_TYPE(result) == AOP_CRY) && ifx){
5456                     jumpIfTrue(ifx);
5457                     goto release;
5458                 }
5459                 pic14_emitcode("clr","c");
5460             }
5461         } else {
5462             if (AOP_TYPE(right) == AOP_CRY){
5463                 // c = bit & bit;
5464                 pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
5465                 pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
5466             } else {
5467                 // c = bit & val;
5468                 MOVA(aopGet(AOP(right),0,FALSE,FALSE));
5469                 // c = lsb
5470                 pic14_emitcode("rrc","a");
5471                 pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
5472             }
5473         }
5474         // bit = c
5475         // val = c
5476         if(size)
5477             pic14_outBitC(result);
5478         // if(bit & ...)
5479         else if((AOP_TYPE(result) == AOP_CRY) && ifx)
5480             genIfxJump(ifx, "c");
5481         goto release ;
5482     }
5483
5484     // if(val & 0xZZ)       - size = 0, ifx != FALSE  -
5485     // bit = val & 0xZZ     - size = 1, ifx = FALSE -
5486     if((AOP_TYPE(right) == AOP_LIT) &&
5487         (AOP_TYPE(result) == AOP_CRY) &&
5488         (AOP_TYPE(left) != AOP_CRY)){
5489         int posbit = isLiteralBit(lit);
5490         /* left &  2^n */
5491         if(posbit){
5492             posbit--;
5493             //MOVA(aopGet(AOP(left),posbit>>3,FALSE,FALSE));
5494             // bit = left & 2^n
5495             if(size)
5496                 pic14_emitcode("mov","c,acc.%d",posbit&0x07);
5497             // if(left &  2^n)
5498             else{
5499                 if(ifx){
5500                     int offset = 0;
5501                     while (posbit > 7) {
5502                         posbit -= 8;
5503                         offset++;
5504                     }
5505                     emitpcode(((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
5506                         newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit,0));
5507                     emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
5508
5509                     ifx->generated = 1;
5510                 }
5511                 goto release;
5512             }
5513         } else {
5514             symbol *tlbl = newiTempLabel(NULL);
5515             int sizel = AOP_SIZE(left);
5516             if(size)
5517                 pic14_emitcode("setb","c");
5518             while(sizel--){
5519                 if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
5520                     mov2w( AOP(left), offset);
5521                     // byte ==  2^n ?
5522                     if((posbit = isLiteralBit(bytelit)) != 0) {
5523                         emitpcode(rIfx.condition ? POC_BTFSC : POC_BTFSS, // XXX: or the other way round?
5524                             newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit - 1, 0));
5525                         pic14_emitcode("jb","acc.%d,%05d_DS_",(posbit-1)&0x07,tlbl->key+100);
5526                     }
5527                     else{
5528                         emitpcode(POC_ANDLW, newpCodeOpLit(bytelit & 0x0ff));
5529                         if (rIfx.condition) emitSKPZ;
5530                         else emitSKPNZ;
5531
5532                         if(bytelit != 0x0FFL)
5533                         {
5534                             pic14_emitcode("anl","a,%s",
5535                             aopGet(AOP(right),offset,FALSE,TRUE));
5536                         }
5537                         pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
5538                     }
5539
5540                     emitpcode(POC_GOTO, popGetLabel(rIfx.lbl->key));
5541                     ifx->generated = 1;
5542
5543                 }
5544                 offset++;
5545             }
5546             // bit = left & literal
5547             if(size){
5548                 pic14_emitcode("clr","c");
5549                 pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5550             }
5551             // if(left & literal)
5552             else{
5553                 if(ifx)
5554                     jmpTrueOrFalse(ifx, tlbl);
5555                 goto release ;
5556             }
5557         }
5558         pic14_outBitC(result);
5559         goto release ;
5560     }
5561
5562     /* if left is same as result */
5563     if(pic14_sameRegs(AOP(result),AOP(left))){
5564         int know_W = -1;
5565         for(;size--; offset++,lit>>=8) {
5566             if(AOP_TYPE(right) == AOP_LIT){
5567                 switch(lit & 0xff) {
5568                 case 0x00:
5569                     /*  and'ing with 0 has clears the result */
5570                     emitpcode(POC_CLRF,popGet(AOP(result),offset));
5571                     break;
5572                 case 0xff:
5573                     /* and'ing with 0xff is a nop when the result and left are the same */
5574                     break;
5575
5576                 default:
5577                     {
5578                         int p = my_powof2( (~lit) & 0xff );
5579                         if(p>=0) {
5580                             /* only one bit is set in the literal, so use a bcf instruction */
5581                             emitpcode(POC_BCF,newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
5582
5583                         } else {
5584                             if(know_W != (int)(lit&0xff))
5585                                 emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
5586                             know_W = lit &0xff;
5587                             emitpcode(POC_ANDWF,popGet(AOP(left),offset));
5588                         }
5589                     }
5590                 }
5591             } else {
5592                 if (AOP_TYPE(left) == AOP_ACC) {
5593                     emitpcode(POC_ANDFW,popGet(AOP(right),offset));
5594                 } else {
5595                     emitpcode(POC_MOVFW,popGet(AOP(right),offset));
5596                     emitpcode(POC_ANDWF,popGet(AOP(left),offset));
5597
5598                 }
5599             }
5600         }
5601
5602     } else {
5603         // left & result in different registers
5604         if(AOP_TYPE(result) == AOP_CRY){
5605             // result = bit
5606             // if(size), result in bit
5607             // if(!size && ifx), conditional oper: if(left & right)
5608             symbol *tlbl = newiTempLabel(NULL);
5609             int sizer = min(AOP_SIZE(left),AOP_SIZE(right));
5610             if(size)
5611                 pic14_emitcode("setb","c");
5612             while(sizer--){
5613                 MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
5614                 pic14_emitcode("anl","a,%s",
5615                     aopGet(AOP(left),offset,FALSE,FALSE));
5616                 pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
5617                 offset++;
5618             }
5619             if(size){
5620                 CLRC;
5621                 pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5622                 pic14_outBitC(result);
5623             } else if(ifx)
5624                 jmpTrueOrFalse(ifx, tlbl);
5625         } else {
5626             for(;(size--);offset++) {
5627                 // normal case
5628                 // result = left & right
5629                 if(AOP_TYPE(right) == AOP_LIT){
5630                     int t = (lit >> (offset*8)) & 0x0FFL;
5631                     switch(t) {
5632                     case 0x00:
5633                         emitpcode(POC_CLRF,popGet(AOP(result),offset));
5634                         break;
5635                     case 0xff:
5636                         if(AOP_TYPE(left) != AOP_ACC) {
5637                             emitpcode(POC_MOVFW,popGet(AOP(left),offset));
5638                         }
5639                         emitpcode(POC_MOVWF,popGet(AOP(result),offset));
5640                         break;
5641                     default:
5642                         if(AOP_TYPE(left) == AOP_ACC) {
5643                             emitpcode(POC_ANDLW, popGetLit(t));
5644                         } else {
5645                             emitpcode(POC_MOVLW, popGetLit(t));
5646                             emitpcode(POC_ANDFW,popGet(AOP(left),offset));
5647                         }
5648                         emitpcode(POC_MOVWF,popGet(AOP(result),offset));
5649                     }
5650                     continue;
5651                 }
5652
5653                 if (AOP_TYPE(left) == AOP_ACC) {
5654                     emitpcode(POC_ANDFW,popGet(AOP(right),offset));
5655                 } else {
5656                     emitpcode(POC_MOVFW,popGet(AOP(right),offset));
5657                     emitpcode(POC_ANDFW,popGet(AOP(left),offset));
5658                 }
5659                 emitpcode(POC_MOVWF,popGet(AOP(result),offset));
5660             }
5661         }
5662     }
5663
5664 release :
5665     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5666     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5667     freeAsmop(result,NULL,ic,TRUE);
5668 }
5669
5670 /*-----------------------------------------------------------------*/
5671 /* genOr  - code for or                                            */
5672 /*-----------------------------------------------------------------*/
5673 static void genOr (iCode *ic, iCode *ifx)
5674 {
5675     operand *left, *right, *result;
5676     int size, offset=0;
5677     unsigned long lit = 0L;
5678
5679     FENTRY;
5680     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5681
5682     aopOp((left = IC_LEFT(ic)),ic,FALSE);
5683     aopOp((right= IC_RIGHT(ic)),ic,FALSE);
5684     aopOp((result=IC_RESULT(ic)),ic,TRUE);
5685
5686     DEBUGpic14_AopType(__LINE__,left,right,result);
5687
5688     /* if left is a literal & right is not then exchange them */
5689     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
5690         AOP_NEEDSACC(left)) {
5691         operand *tmp = right ;
5692         right = left;
5693         left = tmp;
5694     }
5695
5696     /* if result = right then exchange them */
5697     if(pic14_sameRegs(AOP(result),AOP(right))){
5698         operand *tmp = right ;
5699         right = left;
5700         left = tmp;
5701     }
5702
5703     /* if right is bit then exchange them */
5704     if (AOP_TYPE(right) == AOP_CRY &&
5705         AOP_TYPE(left) != AOP_CRY){
5706         operand *tmp = right ;
5707         right = left;
5708         left = tmp;
5709     }
5710
5711     DEBUGpic14_AopType(__LINE__,left,right,result);
5712
5713     if(AOP_TYPE(right) == AOP_LIT)
5714         lit = ulFromVal (AOP(right)->aopu.aop_lit);
5715
5716     size = AOP_SIZE(result);
5717
5718     // if(bit | yy)
5719     // xx = bit | yy;
5720     if (AOP_TYPE(left) == AOP_CRY){
5721         if(AOP_TYPE(right) == AOP_LIT){
5722             // c = bit & literal;
5723             if(lit){
5724                 // lit != 0 => result = 1
5725                 if(AOP_TYPE(result) == AOP_CRY){
5726                     if(size)
5727                         emitpcode(POC_BSF, popGet(AOP(result),0));
5728                     //pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
5729                     //   AOP(result)->aopu.aop_dir,
5730                     //   AOP(result)->aopu.aop_dir);
5731                     else if(ifx)
5732                         continueIfTrue(ifx);
5733                     goto release;
5734                 }
5735             } else {
5736                 // lit == 0 => result = left
5737                 if(size && pic14_sameRegs(AOP(result),AOP(left)))
5738                     goto release;
5739                 pic14_emitcode(";XXX mov","c,%s  %s,%d",AOP(left)->aopu.aop_dir,__FILE__,__LINE__);
5740             }
5741         } else {
5742             if (AOP_TYPE(right) == AOP_CRY){
5743                 if(pic14_sameRegs(AOP(result),AOP(left))){
5744                     // c = bit | bit;
5745                     emitpcode(POC_BCF,   popGet(AOP(result),0));
5746                     emitpcode(POC_BTFSC, popGet(AOP(right),0));
5747                     emitpcode(POC_BSF,   popGet(AOP(result),0));
5748
5749                     pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
5750                         AOP(result)->aopu.aop_dir,
5751                         AOP(result)->aopu.aop_dir);
5752                     pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
5753                         AOP(right)->aopu.aop_dir,
5754                         AOP(right)->aopu.aop_dir);
5755                     pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
5756                         AOP(result)->aopu.aop_dir,
5757                         AOP(result)->aopu.aop_dir);
5758                 } else {
5759                     if( AOP_TYPE(result) == AOP_ACC) {
5760                         emitpcode(POC_MOVLW, popGetLit(0));
5761                         emitpcode(POC_BTFSS, popGet(AOP(right),0));
5762                         emitpcode(POC_BTFSC, popGet(AOP(left),0));
5763                         emitpcode(POC_MOVLW, popGetLit(1));
5764
5765                     } else {
5766
5767                         emitpcode(POC_BCF,   popGet(AOP(result),0));
5768                         emitpcode(POC_BTFSS, popGet(AOP(right),0));
5769                         emitpcode(POC_BTFSC, popGet(AOP(left),0));
5770                         emitpcode(POC_BSF,   popGet(AOP(result),0));
5771
5772                         pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
5773                             AOP(result)->aopu.aop_dir,
5774                             AOP(result)->aopu.aop_dir);
5775                         pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
5776                             AOP(right)->aopu.aop_dir,
5777                             AOP(right)->aopu.aop_dir);
5778                         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
5779                             AOP(left)->aopu.aop_dir,
5780                             AOP(left)->aopu.aop_dir);
5781                         pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
5782                             AOP(result)->aopu.aop_dir,
5783                             AOP(result)->aopu.aop_dir);
5784                     }
5785                 }
5786             } else {
5787                 // c = bit | val;
5788                 symbol *tlbl = newiTempLabel(NULL);
5789                 pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
5790
5791
5792                 emitpcode(POC_BCF,   popGet(AOP(result),0));
5793                 if( AOP_TYPE(right) == AOP_ACC) {
5794                     emitpcode(POC_IORLW, popGetLit(0));
5795                     emitSKPNZ;
5796                     emitpcode(POC_BTFSC, popGet(AOP(left),0));
5797                     emitpcode(POC_BSF,   popGet(AOP(result),0));
5798                 }
5799
5800
5801
5802                 if(!((AOP_TYPE(result) == AOP_CRY) && ifx))
5803                     pic14_emitcode(";XXX setb","c");
5804                 pic14_emitcode(";XXX jb","%s,%05d_DS_",
5805                     AOP(left)->aopu.aop_dir,tlbl->key+100);
5806                 pic14_toBoolean(right);
5807                 pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
5808                 if((AOP_TYPE(result) == AOP_CRY) && ifx){
5809                     jmpTrueOrFalse(ifx, tlbl);
5810                     goto release;
5811                 } else {
5812                     CLRC;
5813                     pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5814                 }
5815             }
5816         }
5817         // bit = c
5818         // val = c
5819         if(size)
5820             pic14_outBitC(result);
5821         // if(bit | ...)
5822         else if((AOP_TYPE(result) == AOP_CRY) && ifx)
5823             genIfxJump(ifx, "c");
5824         goto release ;
5825     }
5826
5827     // if(val | 0xZZ)       - size = 0, ifx != FALSE  -
5828     // bit = val | 0xZZ     - size = 1, ifx = FALSE -
5829     if((AOP_TYPE(right) == AOP_LIT) &&
5830       (AOP_TYPE(result) == AOP_CRY) &&
5831       (AOP_TYPE(left) != AOP_CRY)){
5832         if(lit){
5833             pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
5834             // result = 1
5835             if(size)
5836                 pic14_emitcode(";XXX setb","%s",AOP(result)->aopu.aop_dir);
5837             else
5838                 continueIfTrue(ifx);
5839             goto release;
5840         } else {
5841             pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
5842             // lit = 0, result = boolean(left)
5843             if(size)
5844                 pic14_emitcode(";XXX setb","c");
5845             pic14_toBoolean(right);
5846             if(size){
5847                 symbol *tlbl = newiTempLabel(NULL);
5848                 pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
5849                 CLRC;
5850                 pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5851             } else {
5852                 genIfxJump (ifx,"a");
5853                 goto release;
5854             }
5855         }
5856         pic14_outBitC(result);
5857         goto release ;
5858     }
5859
5860     /* if left is same as result */
5861     if(pic14_sameRegs(AOP(result),AOP(left))){
5862         int know_W = -1;
5863         for(;size--; offset++,lit>>=8) {
5864             if(AOP_TYPE(right) == AOP_LIT){
5865                 if((lit & 0xff) == 0)
5866                     /*  or'ing with 0 has no effect */
5867                     continue;
5868                 else {
5869                     int p = my_powof2(lit & 0xff);
5870                     if(p>=0) {
5871                         /* only one bit is set in the literal, so use a bsf instruction */
5872                         emitpcode(POC_BSF,
5873                             newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
5874                     } else {
5875                         if(know_W != (int)(lit & 0xff))
5876                             emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
5877                         know_W = lit & 0xff;
5878                         emitpcode(POC_IORWF, popGet(AOP(left),offset));
5879                     }
5880
5881                 }
5882             } else {
5883                 if (AOP_TYPE(left) == AOP_ACC) {
5884                     emitpcode(POC_IORFW,  popGet(AOP(right),offset));
5885                     pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
5886                 } else {
5887                     emitpcode(POC_MOVFW,  popGet(AOP(right),offset));
5888                     emitpcode(POC_IORWF,  popGet(AOP(left),offset));
5889
5890                     pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
5891                     pic14_emitcode("iorwf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
5892
5893                 }
5894             }
5895         }
5896     } else {
5897         // left & result in different registers
5898         if(AOP_TYPE(result) == AOP_CRY){
5899             // result = bit
5900             // if(size), result in bit
5901             // if(!size && ifx), conditional oper: if(left | right)
5902             symbol *tlbl = newiTempLabel(NULL);
5903             int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
5904             pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
5905
5906
5907             if(size)
5908                 pic14_emitcode(";XXX setb","c");
5909             while(sizer--){
5910                 MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
5911                 pic14_emitcode(";XXX orl","a,%s",
5912                     aopGet(AOP(left),offset,FALSE,FALSE));
5913                 pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
5914                 offset++;
5915             }
5916             if(size){
5917                 CLRC;
5918                 pic14_emitcode("","%05d_DS_:",tlbl->key+100);
5919                 pic14_outBitC(result);
5920             } else if(ifx)
5921                 jmpTrueOrFalse(ifx, tlbl);
5922         } else for(;(size--);offset++){
5923             // normal case
5924             // result = left | right
5925             if(AOP_TYPE(right) == AOP_LIT){
5926                 int t = (lit >> (offset*8)) & 0x0FFL;
5927                 switch(t) {
5928                 case 0x00:
5929                     if (AOP_TYPE(left) != AOP_ACC) {
5930                         emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
5931                     }
5932                     emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
5933
5934                     break;
5935                 default:
5936                     if (AOP_TYPE(left) == AOP_ACC) {
5937                         emitpcode(POC_IORLW,  popGetLit(t));
5938                     } else {
5939                         emitpcode(POC_MOVLW,  popGetLit(t));
5940                         emitpcode(POC_IORFW,  popGet(AOP(left),offset));
5941                     }
5942                     emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
5943                 }
5944                 continue;
5945             }
5946
5947             // faster than result <- left, anl result,right
5948             // and better if result is SFR
5949             if (AOP_TYPE(left) == AOP_ACC) {
5950                 emitpcode(POC_IORFW,popGet(AOP(right),offset));
5951             } else {
5952                 emitpcode(POC_MOVFW,popGet(AOP(right),offset));
5953                 emitpcode(POC_IORFW,popGet(AOP(left),offset));
5954             }
5955             emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
5956         }
5957     }
5958
5959 release :
5960     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5961     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5962     freeAsmop(result,NULL,ic,TRUE);
5963 }
5964
5965 /*-----------------------------------------------------------------*/
5966 /* genXor - code for xclusive or                                   */
5967 /*-----------------------------------------------------------------*/
5968 static void genXor (iCode *ic, iCode *ifx)
5969 {
5970     operand *left, *right, *result;
5971     int size, offset=0;
5972     unsigned long lit = 0L;
5973
5974     FENTRY;
5975     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
5976
5977     aopOp((left = IC_LEFT(ic)),ic,FALSE);
5978     aopOp((right= IC_RIGHT(ic)),ic,FALSE);
5979     aopOp((result=IC_RESULT(ic)),ic,TRUE);
5980
5981     /* if left is a literal & right is not ||
5982     if left needs acc & right does not */
5983     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
5984         (AOP_NEEDSACC(left) && !AOP_NEEDSACC(right))) {
5985         operand *tmp = right ;
5986         right = left;
5987         left = tmp;
5988     }
5989
5990     /* if result = right then exchange them */
5991     if(pic14_sameRegs(AOP(result),AOP(right))){
5992         operand *tmp = right ;
5993         right = left;
5994         left = tmp;
5995     }
5996
5997     /* if right is bit then exchange them */
5998     if (AOP_TYPE(right) == AOP_CRY &&
5999         AOP_TYPE(left) != AOP_CRY){
6000         operand *tmp = right ;
6001         right = left;
6002         left = tmp;
6003     }
6004     if(AOP_TYPE(right) == AOP_LIT)
6005         lit = ulFromVal (AOP(right)->aopu.aop_lit);
6006
6007     size = AOP_SIZE(result);
6008
6009     // if(bit ^ yy)
6010     // xx = bit ^ yy;
6011     if (AOP_TYPE(left) == AOP_CRY){
6012         if(AOP_TYPE(right) == AOP_LIT){
6013             // c = bit & literal;
6014             if(lit>>1){
6015                 // lit>>1  != 0 => result = 1
6016                 if(AOP_TYPE(result) == AOP_CRY){
6017                     if(size)
6018                     {emitpcode(POC_BSF,  popGet(AOP(result),offset));
6019                     pic14_emitcode("setb","%s",AOP(result)->aopu.aop_dir);}
6020                     else if(ifx)
6021                         continueIfTrue(ifx);
6022                     goto release;
6023                 }
6024                 pic14_emitcode("setb","c");
6025             } else{
6026                 // lit == (0 or 1)
6027                 if(lit == 0){
6028                     // lit == 0, result = left
6029                     if(size && pic14_sameRegs(AOP(result),AOP(left)))
6030                         goto release;
6031                     pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
6032                 } else{
6033                     // lit == 1, result = not(left)
6034                     if(size && pic14_sameRegs(AOP(result),AOP(left))){
6035                         emitpcode(POC_MOVLW,  popGet(AOP(result),offset));
6036                         emitpcode(POC_XORWF,  popGet(AOP(result),offset));
6037                         pic14_emitcode("cpl","%s",AOP(result)->aopu.aop_dir);
6038                         goto release;
6039                     } else {
6040                         assert ( !"incomplete genXor" );
6041                         pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
6042                         pic14_emitcode("cpl","c");
6043                     }
6044                 }
6045             }
6046
6047         } else {
6048             // right != literal
6049             symbol *tlbl = newiTempLabel(NULL);
6050             if (AOP_TYPE(right) == AOP_CRY){
6051                 // c = bit ^ bit;
6052                 pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
6053             }
6054             else{
6055                 int sizer = AOP_SIZE(right);
6056                 // c = bit ^ val
6057                 // if val>>1 != 0, result = 1
6058                 pic14_emitcode("setb","c");
6059                 while(sizer){
6060                     MOVA(aopGet(AOP(right),sizer-1,FALSE,FALSE));
6061                     if(sizer == 1)
6062                         // test the msb of the lsb
6063                         pic14_emitcode("anl","a,#0xfe");
6064                     pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
6065                     sizer--;
6066                 }
6067                 // val = (0,1)
6068                 pic14_emitcode("rrc","a");
6069             }
6070             pic14_emitcode("jnb","%s,%05d_DS_",AOP(left)->aopu.aop_dir,(tlbl->key+100));
6071             pic14_emitcode("cpl","c");
6072             pic14_emitcode("","%05d_DS_:",(tlbl->key+100));
6073         }
6074         // bit = c
6075         // val = c
6076         if(size)
6077             pic14_outBitC(result);
6078         // if(bit | ...)
6079         else if((AOP_TYPE(result) == AOP_CRY) && ifx)
6080             genIfxJump(ifx, "c");
6081         goto release ;
6082     }
6083
6084     if(pic14_sameRegs(AOP(result),AOP(left))){
6085         /* if left is same as result */
6086         for(;size--; offset++) {
6087             if(AOP_TYPE(right) == AOP_LIT){
6088                 int t  = (lit >> (offset*8)) & 0x0FFL;
6089                 if(t == 0x00L)
6090                     continue;
6091                 else
6092                     if (IS_AOP_PREG(left)) {
6093                         MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
6094                         pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
6095                         aopPut(AOP(result),"a",offset);
6096                     } else {
6097                         emitpcode(POC_MOVLW, popGetLit(t));
6098                         emitpcode(POC_XORWF,popGet(AOP(left),offset));
6099                         pic14_emitcode("xrl","%s,%s",
6100                             aopGet(AOP(left),offset,FALSE,TRUE),
6101                             aopGet(AOP(right),offset,FALSE,FALSE));
6102                     }
6103             } else {
6104                 if (AOP_TYPE(left) == AOP_ACC)
6105                     pic14_emitcode("xrl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE));
6106                 else {
6107                     emitpcode(POC_MOVFW,popGet(AOP(right),offset));
6108                     emitpcode(POC_XORWF,popGet(AOP(left),offset));
6109                     /*
6110                     if (IS_AOP_PREG(left)) {
6111                     pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
6112                     aopPut(AOP(result),"a",offset);
6113                     } else
6114                     pic14_emitcode("xrl","%s,a",
6115                     aopGet(AOP(left),offset,FALSE,TRUE));
6116                     */
6117                 }
6118             }
6119         }
6120     } else {
6121         // left & result in different registers
6122         if(AOP_TYPE(result) == AOP_CRY){
6123             // result = bit
6124             // if(size), result in bit
6125             // if(!size && ifx), conditional oper: if(left ^ right)
6126             symbol *tlbl = newiTempLabel(NULL);
6127             int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
6128             if(size)
6129                 pic14_emitcode("setb","c");
6130             while(sizer--){
6131                 if((AOP_TYPE(right) == AOP_LIT) &&
6132                     (((lit >> (offset*8)) & 0x0FFL) == 0x00L)){
6133                     MOVA(aopGet(AOP(left),offset,FALSE,FALSE));
6134                 } else {
6135                     MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
6136                     pic14_emitcode("xrl","a,%s",
6137                         aopGet(AOP(left),offset,FALSE,FALSE));
6138                 }
6139                 pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
6140                 offset++;
6141             }
6142             if(size){
6143                 CLRC;
6144                 pic14_emitcode("","%05d_DS_:",tlbl->key+100);
6145                 pic14_outBitC(result);
6146             } else if(ifx)
6147                 jmpTrueOrFalse(ifx, tlbl);
6148         } else for(;(size--);offset++){
6149             // normal case
6150             // result = left & right
6151             if(AOP_TYPE(right) == AOP_LIT){
6152                 int t = (lit >> (offset*8)) & 0x0FFL;
6153                 switch(t) {
6154                 case 0x00:
6155                     if (AOP_TYPE(left) != AOP_ACC) {
6156                         emitpcode(POC_MOVFW,popGet(AOP(left),offset));
6157                     }
6158                     emitpcode(POC_MOVWF,popGet(AOP(result),offset));
6159                     pic14_emitcode("movf","%s,w",
6160                         aopGet(AOP(left),offset,FALSE,FALSE));
6161                     pic14_emitcode("movwf","%s",
6162                         aopGet(AOP(result),offset,FALSE,FALSE));
6163                     break;
6164                 case 0xff:
6165                     if (AOP_TYPE(left) == AOP_ACC) {
6166                         emitpcode(POC_XORLW, popGetLit(t));
6167                     } else {
6168                         emitpcode(POC_COMFW,popGet(AOP(left),offset));
6169                     }
6170                     emitpcode(POC_MOVWF,popGet(AOP(result),offset));
6171                     break;
6172                 default:
6173                     if (AOP_TYPE(left) == AOP_ACC) {
6174                         emitpcode(POC_XORLW, popGetLit(t));
6175                     } else {
6176                         emitpcode(POC_MOVLW, popGetLit(t));
6177                         emitpcode(POC_XORFW,popGet(AOP(left),offset));
6178                     }
6179                     emitpcode(POC_MOVWF,popGet(AOP(result),offset));
6180                     pic14_emitcode("movlw","0x%x",t);
6181                     pic14_emitcode("xorwf","%s,w",
6182                         aopGet(AOP(left),offset,FALSE,FALSE));
6183                     pic14_emitcode("movwf","%s",
6184                         aopGet(AOP(result),offset,FALSE,FALSE));
6185
6186                 }
6187                 continue;
6188             }
6189
6190             // faster than result <- left, anl result,right
6191             // and better if result is SFR
6192             if (AOP_TYPE(left) == AOP_ACC) {
6193                 emitpcode(POC_XORFW,popGet(AOP(right),offset));
6194             } else {
6195                 emitpcode(POC_MOVFW,popGet(AOP(right),offset));
6196                 emitpcode(POC_XORFW,popGet(AOP(left),offset));
6197             }
6198             if ( AOP_TYPE(result) != AOP_ACC){
6199                 emitpcode(POC_MOVWF,popGet(AOP(result),offset));
6200             }
6201         }
6202     }
6203
6204 release :
6205     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
6206     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
6207     freeAsmop(result,NULL,ic,TRUE);
6208 }
6209
6210 /*-----------------------------------------------------------------*/
6211 /* genInline - write the inline code out                           */
6212 /*-----------------------------------------------------------------*/
6213 static void genInline (iCode *ic)
6214 {
6215   char *buffer, *bp, *bp1;
6216   bool inComment = FALSE;
6217
6218   FENTRY;
6219   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6220
6221   _G.inLine += (!options.asmpeep);
6222
6223   buffer = bp = bp1 = Safe_strdup (IC_INLINE (ic));
6224
6225   while (*bp)
6226     {
6227       switch (*bp)
6228         {
6229         case ';':
6230           inComment = TRUE;
6231           ++bp;
6232           break;
6233
6234         case '\n':
6235           inComment = FALSE;
6236           *bp++ = '\0';
6237           if (*bp1)
6238             addpCode2pBlock(pb, newpCodeAsmDir(bp1, NULL)); // inline directly, no process
6239           bp1 = bp;
6240           break;
6241
6242         default:
6243           /* Add \n for labels, not dirs such as c:\mydir */
6244           if (!inComment && (*bp == ':') && (isspace((unsigned char)bp[1])))
6245             {
6246               ++bp;
6247               *bp = '\0';
6248               ++bp;
6249               /* print label, use this special format with NULL directive
6250                * to denote that the argument should not be indented with tab */
6251               addpCode2pBlock(pb, newpCodeAsmDir(NULL, bp1)); // inline directly, no process
6252               bp1 = bp;
6253             }
6254           else
6255             ++bp;
6256           break;
6257         }
6258     }
6259   if ((bp1 != bp) && *bp1)
6260     addpCode2pBlock(pb, newpCodeAsmDir(bp1, NULL)); // inline directly, no process
6261
6262   Safe_free (buffer);
6263
6264   _G.inLine -= (!options.asmpeep);
6265 }
6266
6267 /*-----------------------------------------------------------------*/
6268 /* genRRC - rotate right with carry                                */
6269 /*-----------------------------------------------------------------*/
6270 static void genRRC (iCode *ic)
6271 {
6272     operand *left , *result ;
6273     int size, offset = 0, same;
6274
6275     FENTRY;
6276     /* rotate right with carry */
6277     left = IC_LEFT(ic);
6278     result=IC_RESULT(ic);
6279     aopOp (left,ic,FALSE);
6280     aopOp (result,ic,FALSE);
6281
6282     DEBUGpic14_AopType(__LINE__,left,NULL,result);
6283
6284     same = pic14_sameRegs(AOP(result),AOP(left));
6285
6286     size = AOP_SIZE(result);
6287
6288     /* get the lsb and put it into the carry */
6289     emitpcode(POC_RRFW, popGet(AOP(left),size-1));
6290
6291     offset = 0 ;
6292
6293     while(size--) {
6294
6295         if(same) {
6296             emitpcode(POC_RRF, popGet(AOP(left),offset));
6297         } else {
6298             emitpcode(POC_RRFW, popGet(AOP(left),offset));
6299             emitpcode(POC_MOVWF, popGet(AOP(result),offset));
6300         }
6301
6302         offset++;
6303     }
6304
6305     freeAsmop(left,NULL,ic,TRUE);
6306     freeAsmop(result,NULL,ic,TRUE);
6307 }
6308
6309 /*-----------------------------------------------------------------*/
6310 /* genRLC - generate code for rotate left with carry               */
6311 /*-----------------------------------------------------------------*/
6312 static void genRLC (iCode *ic)
6313 {
6314     operand *left , *result ;
6315     int size, offset = 0;
6316     int same;
6317
6318     FENTRY;
6319     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6320     /* rotate right with carry */
6321     left = IC_LEFT(ic);
6322     result=IC_RESULT(ic);
6323     aopOp (left,ic,FALSE);
6324     aopOp (result,ic,FALSE);
6325
6326     DEBUGpic14_AopType(__LINE__,left,NULL,result);
6327
6328     same = pic14_sameRegs(AOP(result),AOP(left));
6329
6330     /* move it to the result */
6331     size = AOP_SIZE(result);
6332
6333     /* get the msb and put it into the carry */
6334     emitpcode(POC_RLFW, popGet(AOP(left),size-1));
6335
6336     offset = 0 ;
6337
6338     while(size--) {
6339
6340         if(same) {
6341             emitpcode(POC_RLF, popGet(AOP(left),offset));
6342         } else {
6343             emitpcode(POC_RLFW, popGet(AOP(left),offset));
6344             emitpcode(POC_MOVWF, popGet(AOP(result),offset));
6345         }
6346
6347         offset++;
6348     }
6349
6350
6351     freeAsmop(left,NULL,ic,TRUE);
6352     freeAsmop(result,NULL,ic,TRUE);
6353 }
6354
6355 /*-----------------------------------------------------------------*/
6356 /* genGetHbit - generates code get highest order bit               */
6357 /*-----------------------------------------------------------------*/
6358 static void genGetHbit (iCode *ic)
6359 {
6360     operand *left, *result;
6361     left = IC_LEFT(ic);
6362     result=IC_RESULT(ic);
6363     aopOp (left,ic,FALSE);
6364     aopOp (result,ic,FALSE);
6365
6366     FENTRY;
6367     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6368     /* get the highest order byte into a */
6369     MOVA(aopGet(AOP(left),AOP_SIZE(left) - 1,FALSE,FALSE));
6370     if(AOP_TYPE(result) == AOP_CRY){
6371         pic14_emitcode("rlc","a");
6372         pic14_outBitC(result);
6373     }
6374     else{
6375         pic14_emitcode("rl","a");
6376         pic14_emitcode("anl","a,#0x01");
6377         pic14_outAcc(result);
6378     }
6379
6380
6381     freeAsmop(left,NULL,ic,TRUE);
6382     freeAsmop(result,NULL,ic,TRUE);
6383 }
6384
6385 /*-----------------------------------------------------------------*/
6386 /* AccLsh - shift left accumulator by known count                  */
6387 /* MARK: pic14 always rotates through CARRY!                       */
6388 /*-----------------------------------------------------------------*/
6389 static void AccLsh (pCodeOp *pcop,int shCount)
6390 {
6391     FENTRY;
6392     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6393     shCount &= 0x0007;              // shCount : 0..7
6394     switch(shCount){
6395     case 0 :
6396         return;
6397         break;
6398     case 1 :
6399         emitCLRC;
6400         emitpcode(POC_RLF,pcop);
6401         return;
6402         break;
6403     case 2 :
6404         emitpcode(POC_RLF,pcop);
6405         emitpcode(POC_RLF,pcop);
6406         break;
6407     case 3 :
6408         emitpcode(POC_RLF,pcop);
6409         emitpcode(POC_RLF,pcop);
6410         emitpcode(POC_RLF,pcop);
6411         break;
6412     case 4 :
6413         emitpcode(POC_SWAPF,pcop);
6414         break;
6415     case 5 :
6416         emitpcode(POC_SWAPF,pcop);
6417         emitpcode(POC_RLF,pcop);
6418         break;
6419     case 6 :
6420         emitpcode(POC_SWAPF,pcop);
6421         emitpcode(POC_RLF,pcop);
6422         emitpcode(POC_RLF,pcop);
6423         break;
6424     case 7 :
6425         emitpcode(POC_RRFW,pcop);
6426         emitpcode(POC_RRF,pcop);
6427         break;
6428     }
6429     /* clear invalid bits */
6430     emitpcode(POC_MOVLW, popGetLit ((unsigned char)(~((1UL << shCount) - 1))));
6431     emitpcode(POC_ANDWF, pcop);
6432 }
6433
6434 /*-----------------------------------------------------------------*/
6435 /* AccRsh - shift right accumulator by known count                 */
6436 /* MARK: pic14 always rotates through CARRY!                       */
6437 /* maskmode - 0: leave invalid bits undefined (caller should mask) */
6438 /*            1: mask out invalid bits (zero-extend)               */
6439 /*            2: sign-extend result (pretty slow)                  */
6440 /*-----------------------------------------------------------------*/
6441 static void AccRsh (pCodeOp *pcop,int shCount, int mask_mode)
6442 {
6443     FENTRY;
6444     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6445     shCount &= 0x0007;              // shCount : 0..7
6446     switch(shCount){
6447     case 0 :
6448         return;
6449         break;
6450     case 1 :
6451         /* load sign if needed */
6452         if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
6453         else if (mask_mode == 1) emitCLRC;
6454         emitpcode(POC_RRF,pcop);
6455         return;
6456         break;
6457     case 2 :
6458         /* load sign if needed */
6459         if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
6460         emitpcode(POC_RRF,pcop);
6461         /* load sign if needed */
6462         if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
6463         emitpcode(POC_RRF,pcop);
6464         if (mask_mode == 2) return;
6465         break;
6466     case 3 :
6467         /* load sign if needed */
6468         if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
6469         emitpcode(POC_RRF,pcop);
6470         /* load sign if needed */
6471         if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
6472         emitpcode(POC_RRF,pcop);
6473         /* load sign if needed */
6474         if (mask_mode == 2) emitpcode(POC_RLFW,pcop);
6475         emitpcode(POC_RRF,pcop);
6476         if (mask_mode == 2) return;
6477         break;
6478     case 4 :
6479         emitpcode(POC_SWAPF,pcop);
6480         break;
6481     case 5 :
6482         emitpcode(POC_SWAPF,pcop);
6483         emitpcode(POC_RRF,pcop);
6484         break;
6485     case 6 :
6486         emitpcode(POC_SWAPF,pcop);
6487         emitpcode(POC_RRF,pcop);
6488         emitpcode(POC_RRF,pcop);
6489         break;
6490     case 7 :
6491         if (mask_mode == 2)
6492         {
6493             /* load sign */
6494             emitpcode(POC_RLFW,pcop);
6495             emitpcode(POC_CLRF,pcop);
6496             emitSKPNC;
6497             emitpcode(POC_COMF,pcop);
6498             return;
6499         } else {
6500             emitpcode(POC_RLFW,pcop);
6501             emitpcode(POC_RLF,pcop);
6502         }
6503         break;
6504     }
6505
6506     if (mask_mode == 0)
6507     {
6508         /* leave invalid bits undefined */
6509         return;
6510     }
6511
6512     /* clear invalid bits -- zero-extend */
6513     emitpcode(POC_MOVLW, popGetLit (0x00ff >> shCount));
6514     emitpcode(POC_ANDWF, pcop);
6515
6516     if (mask_mode == 2) {
6517       /* sign-extend */
6518       emitpcode(POC_MOVLW, popGetLit (0x00ff << (8 - shCount)));
6519       emitpcode(POC_BTFSC, newpCodeOpBit (get_op(pcop,NULL,0), 7 - shCount ,0));
6520       emitpcode(POC_IORWF, pcop);
6521     }
6522 }
6523
6524 #if 0
6525 /*-----------------------------------------------------------------*/
6526 /* AccSRsh - signed right shift accumulator by known count                 */
6527 /*-----------------------------------------------------------------*/
6528 static void AccSRsh (int shCount)
6529 {
6530     symbol *tlbl ;
6531     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6532     if(shCount != 0){
6533         if(shCount == 1){
6534             pic14_emitcode("mov","c,acc.7");
6535             pic14_emitcode("rrc","a");
6536         } else if(shCount == 2){
6537             pic14_emitcode("mov","c,acc.7");
6538             pic14_emitcode("rrc","a");
6539             pic14_emitcode("mov","c,acc.7");
6540             pic14_emitcode("rrc","a");
6541         } else {
6542             tlbl = newiTempLabel(NULL);
6543             /* rotate right accumulator */
6544             AccRol(8 - shCount);
6545             /* and kill the higher order bits */
6546             pic14_emitcode("anl","a,#0x%02x", SRMask[shCount]);
6547             pic14_emitcode("jnb","acc.%d,%05d_DS_",7-shCount,tlbl->key+100);
6548             pic14_emitcode("orl","a,#0x%02x",
6549                 (unsigned char)~SRMask[shCount]);
6550             pic14_emitcode("","%05d_DS_:",tlbl->key+100);
6551         }
6552     }
6553 }
6554
6555 /*-----------------------------------------------------------------*/
6556 /* shiftR1Left2Result - shift right one byte from left to result   */
6557 /*-----------------------------------------------------------------*/
6558 static void shiftR1Left2ResultSigned (operand *left, int offl,
6559                                       operand *result, int offr,
6560                                       int shCount)
6561 {
6562     int same;
6563
6564     FENTRY;
6565     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6566
6567     same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
6568
6569     switch(shCount) {
6570     case 1:
6571         emitpcode(POC_RLFW, popGet(AOP(left),offl));
6572         if(same)
6573             emitpcode(POC_RRF, popGet(AOP(result),offr));
6574         else {
6575             emitpcode(POC_RRFW, popGet(AOP(left),offl));
6576             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6577         }
6578
6579         break;
6580     case 2:
6581
6582         emitpcode(POC_RLFW, popGet(AOP(left),offl));
6583         if(same)
6584             emitpcode(POC_RRF, popGet(AOP(result),offr));
6585         else {
6586             emitpcode(POC_RRFW, popGet(AOP(left),offl));
6587             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6588         }
6589         emitpcode(POC_RLFW, popGet(AOP(result),offr));
6590         emitpcode(POC_RRF,  popGet(AOP(result),offr));
6591
6592         break;
6593
6594     case 3:
6595         if(same)
6596             emitpcode(POC_SWAPF, popGet(AOP(result),offr));
6597         else {
6598             emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
6599             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6600         }
6601
6602         emitpcode(POC_RLFW,  popGet(AOP(result),offr));
6603         emitpcode(POC_RLFW,  popGet(AOP(result),offr));
6604         emitpcode(POC_ANDLW, popGetLit(0x1f));
6605
6606         emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
6607         emitpcode(POC_IORLW, popGetLit(0xe0));
6608
6609         emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6610         break;
6611
6612     case 4:
6613         emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
6614         emitpcode(POC_ANDLW,  popGetLit(0x0f));
6615         emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
6616         emitpcode(POC_IORLW,  popGetLit(0xf0));
6617         emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
6618         break;
6619     case 5:
6620         if(same) {
6621             emitpcode(POC_SWAPF,  popGet(AOP(result),offr));
6622         } else {
6623             emitpcode(POC_SWAPFW,  popGet(AOP(left),offl));
6624             emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
6625         }
6626         emitpcode(POC_RRFW,   popGet(AOP(result),offr));
6627         emitpcode(POC_ANDLW,  popGetLit(0x07));
6628         emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
6629         emitpcode(POC_IORLW,  popGetLit(0xf8));
6630         emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
6631         break;
6632
6633     case 6:
6634         if(same) {
6635             emitpcode(POC_MOVLW, popGetLit(0x00));
6636             emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
6637             emitpcode(POC_MOVLW, popGetLit(0xfe));
6638             emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
6639             emitpcode(POC_IORLW, popGetLit(0x01));
6640             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6641         } else {
6642             emitpcode(POC_CLRF,  popGet(AOP(result),offr));
6643             emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
6644             emitpcode(POC_DECF,  popGet(AOP(result),offr));
6645             emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
6646             emitpcode(POC_BCF,   newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),0,0));
6647         }
6648         break;
6649
6650     case 7:
6651         if(same) {
6652             emitpcode(POC_MOVLW, popGetLit(0x00));
6653             emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
6654             emitpcode(POC_MOVLW, popGetLit(0xff));
6655             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6656         } else {
6657             emitpcode(POC_CLRF,  popGet(AOP(result),offr));
6658             emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
6659             emitpcode(POC_DECF,  popGet(AOP(result),offr));
6660         }
6661
6662     default:
6663         break;
6664     }
6665 }
6666
6667 /*-----------------------------------------------------------------*/
6668 /* shiftR1Left2Result - shift right one byte from left to result   */
6669 /*-----------------------------------------------------------------*/
6670 static void shiftR1Left2Result (operand *left, int offl,
6671                                 operand *result, int offr,
6672                                 int shCount, int sign)
6673 {
6674     int same;
6675
6676     FENTRY;
6677     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6678
6679     same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
6680
6681     /* Copy the msb into the carry if signed. */
6682     if(sign) {
6683         shiftR1Left2ResultSigned(left,offl,result,offr,shCount);
6684         return;
6685     }
6686
6687
6688
6689     switch(shCount) {
6690     case 1:
6691         emitCLRC;
6692         if(same)
6693             emitpcode(POC_RRF, popGet(AOP(result),offr));
6694         else {
6695             emitpcode(POC_RRFW, popGet(AOP(left),offl));
6696             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6697         }
6698         break;
6699     case 2:
6700         emitCLRC;
6701         if(same) {
6702             emitpcode(POC_RRF, popGet(AOP(result),offr));
6703         } else {
6704             emitpcode(POC_RRFW, popGet(AOP(left),offl));
6705             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6706         }
6707         emitCLRC;
6708         emitpcode(POC_RRF, popGet(AOP(result),offr));
6709
6710         break;
6711     case 3:
6712         if(same)
6713             emitpcode(POC_SWAPF, popGet(AOP(result),offr));
6714         else {
6715             emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
6716             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6717         }
6718
6719         emitpcode(POC_RLFW,  popGet(AOP(result),offr));
6720         emitpcode(POC_RLFW,  popGet(AOP(result),offr));
6721         emitpcode(POC_ANDLW, popGetLit(0x1f));
6722         emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6723         break;
6724
6725     case 4:
6726         emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
6727         emitpcode(POC_ANDLW, popGetLit(0x0f));
6728         emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6729         break;
6730
6731     case 5:
6732         emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
6733         emitpcode(POC_ANDLW, popGetLit(0x0f));
6734         emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6735         emitCLRC;
6736         emitpcode(POC_RRF, popGet(AOP(result),offr));
6737
6738         break;
6739     case 6:
6740
6741         emitpcode(POC_RLFW,  popGet(AOP(left),offl));
6742         emitpcode(POC_ANDLW, popGetLit(0x80));
6743         emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6744         emitpcode(POC_RLF,   popGet(AOP(result),offr));
6745         emitpcode(POC_RLF,   popGet(AOP(result),offr));
6746         break;
6747
6748     case 7:
6749
6750         emitpcode(POC_RLFW, popGet(AOP(left),offl));
6751         emitpcode(POC_CLRF, popGet(AOP(result),offr));
6752         emitpcode(POC_RLF,  popGet(AOP(result),offr));
6753
6754         break;
6755
6756     default:
6757         break;
6758     }
6759 }
6760
6761 /*-----------------------------------------------------------------*/
6762 /* shiftL1Left2Result - shift left one byte from left to result    */
6763 /*-----------------------------------------------------------------*/
6764 static void shiftL1Left2Result (operand *left, int offl,
6765                                 operand *result, int offr, int shCount)
6766 {
6767     int same;
6768
6769     //    char *l;
6770     FENTRY;
6771     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6772
6773     same = ((left == result) || (AOP(left) == AOP(result))) && (offl==offr);
6774     DEBUGpic14_emitcode ("; ***","same =  %d",same);
6775     //    l = aopGet(AOP(left),offl,FALSE,FALSE);
6776     //    MOVA(l);
6777     /* shift left accumulator */
6778     //AccLsh(shCount); // don't comment out just yet...
6779     //    aopPut(AOP(result),"a",offr);
6780
6781     switch(shCount) {
6782     case 1:
6783         /* Shift left 1 bit position */
6784         emitpcode(POC_MOVFW, popGet(AOP(left),offl));
6785         if(same) {
6786             emitpcode(POC_ADDWF, popGet(AOP(left),offl));
6787         } else {
6788             emitpcode(POC_ADDFW, popGet(AOP(left),offl));
6789             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6790         }
6791         break;
6792     case 2:
6793         emitpcode(POC_RLFW, popGet(AOP(left),offl));
6794         emitpcode(POC_ANDLW,popGetLit(0x7e));
6795         emitpcode(POC_MOVWF,popGet(AOP(result),offr));
6796         emitpcode(POC_ADDWF,popGet(AOP(result),offr));
6797         break;
6798     case 3:
6799         emitpcode(POC_RLFW, popGet(AOP(left),offl));
6800         emitpcode(POC_ANDLW,popGetLit(0x3e));
6801         emitpcode(POC_MOVWF,popGet(AOP(result),offr));
6802         emitpcode(POC_ADDWF,popGet(AOP(result),offr));
6803         emitpcode(POC_RLF,  popGet(AOP(result),offr));
6804         break;
6805     case 4:
6806         emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
6807         emitpcode(POC_ANDLW, popGetLit(0xf0));
6808         emitpcode(POC_MOVWF,popGet(AOP(result),offr));
6809         break;
6810     case 5:
6811         emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
6812         emitpcode(POC_ANDLW, popGetLit(0xf0));
6813         emitpcode(POC_MOVWF,popGet(AOP(result),offr));
6814         emitpcode(POC_ADDWF,popGet(AOP(result),offr));
6815         break;
6816     case 6:
6817         emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
6818         emitpcode(POC_ANDLW, popGetLit(0x30));
6819         emitpcode(POC_MOVWF,popGet(AOP(result),offr));
6820         emitpcode(POC_ADDWF,popGet(AOP(result),offr));
6821         emitpcode(POC_RLF,  popGet(AOP(result),offr));
6822         break;
6823     case 7:
6824         emitpcode(POC_RRFW, popGet(AOP(left),offl));
6825         emitpcode(POC_CLRF, popGet(AOP(result),offr));
6826         emitpcode(POC_RRF,  popGet(AOP(result),offr));
6827         break;
6828
6829     default:
6830         DEBUGpic14_emitcode ("; ***","%s  %d, shift count is %d",__FUNCTION__,__LINE__,shCount);
6831     }
6832
6833 }
6834 #endif
6835
6836 /*-----------------------------------------------------------------*/
6837 /* movLeft2Result - move byte from left to result                  */
6838 /*-----------------------------------------------------------------*/
6839 static void movLeft2Result (operand *left, int offl,
6840                             operand *result, int offr)
6841 {
6842     char *l;
6843     FENTRY;
6844     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
6845     if(!pic14_sameRegs(AOP(left),AOP(result)) || (offl != offr)){
6846         l = aopGet(AOP(left),offl,FALSE,FALSE);
6847
6848         if (*l == '@' && (IS_AOP_PREG(result))) {
6849             pic14_emitcode("mov","a,%s",l);
6850             aopPut(AOP(result),"a",offr);
6851         } else {
6852             emitpcode(POC_MOVFW, popGet(AOP(left),offl));
6853             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
6854         }
6855     }
6856 }
6857
6858 /*-----------------------------------------------------------------*/
6859 /* shiftLeft_Left2ResultLit - shift left by known count            */
6860 /*-----------------------------------------------------------------*/
6861
6862 static void shiftLeft_Left2ResultLit (operand *left, operand *result, int shCount)
6863 {
6864     int size, same, offr, i;
6865
6866     size = AOP_SIZE(left);
6867     if (AOP_SIZE(result) < size) size = AOP_SIZE(result);
6868
6869     same = pic14_sameRegs (AOP(left), AOP(result));
6870
6871     offr = shCount / 8;
6872     shCount = shCount & 0x07;
6873
6874     size -= offr;
6875
6876     switch (shCount)
6877     {
6878     case 0: /* takes 0 or 2N cycles (for offr==0) */
6879         if (!same || offr) {
6880             for (i=size-1; i >= 0; i--)
6881                 movLeft2Result (left, i, result, offr + i);
6882         } // if
6883         break;
6884
6885     case 1: /* takes 1N+1 or 2N+1 cycles (or offr==0) */
6886         if (same && offr) {
6887             shiftLeft_Left2ResultLit (left, result, 8 * offr);
6888             shiftLeft_Left2ResultLit (result, result, shCount);
6889             return; /* prevent clearing result again */
6890         } else {
6891             emitCLRC;
6892             for (i=0; i < size; i++) {
6893                 if (same && !offr) {
6894                     emitpcode (POC_RLF, popGet (AOP(left), i));
6895                 } else {
6896                     emitpcode (POC_RLFW, popGet (AOP(left), i));
6897                     emitpcode (POC_MOVWF, popGet (AOP(result), i + offr));
6898                 } // if
6899             } // for
6900         } // if (offr)
6901         break;
6902
6903     case 4: /* takes 3+5(N-1) = 5N-2 cycles (for offr==0) */
6904         /* works in-place/with offr as well */
6905         emitpcode (POC_SWAPFW, popGet (AOP(left), size-1));
6906         emitpcode (POC_ANDLW, popGetLit (0xF0));
6907         emitpcode (POC_MOVWF, popGet(AOP(result), size-1+offr));
6908
6909         for (i = size - 2; i >= 0; i--)
6910         {
6911             emitpcode (POC_SWAPFW, popGet (AOP(left), i));
6912             emitpcode (POC_MOVWF, popGet (AOP(result), i + offr));
6913             emitpcode (POC_ANDLW, popGetLit (0x0F));
6914             emitpcode (POC_IORWF, popGet (AOP(result), i + offr + 1));
6915             emitpcode (POC_XORWF, popGet (AOP(result), i + offr));
6916         } // for i
6917         break;
6918
6919     case 7: /* takes 2(N-1)+3 = 2N+1 cycles */
6920         /* works in-place/with offr as well */
6921         emitpcode (POC_RRFW, popGet (AOP(left), size-1));
6922         for (i = size-2; i >= 0; i--) {
6923             emitpcode (POC_RRFW, popGet (AOP(left), i));
6924             emitpcode (POC_MOVWF, popGet (AOP(result), offr + i + 1));
6925         } // for i
6926         emitpcode (POC_CLRF, popGet (AOP(result), offr));
6927         emitpcode (POC_RRF, popGet (AOP(result), offr));
6928         break;
6929
6930     default:
6931         shiftLeft_Left2ResultLit (left, result, offr * 8 + shCount-1);
6932         shiftLeft_Left2ResultLit (result, result, 1);
6933         return; /* prevent clearing result again */
6934         break;
6935     } // switch
6936
6937     while (0 < offr--)
6938     {
6939         emitpcode (POC_CLRF, popGet (AOP(result), offr));
6940     } // while
6941 }
6942
6943 /*-----------------------------------------------------------------*/
6944 /* shiftRight_Left2ResultLit - shift right by known count          */
6945 /*-----------------------------------------------------------------*/
6946
6947 static void shiftRight_Left2ResultLit (operand *left, operand *result, int shCount, int sign)
6948 {
6949     int size, same, offr, i;
6950
6951     size = AOP_SIZE(left);
6952     if (AOP_SIZE(result) < size) size = AOP_SIZE(result);
6953
6954     same = pic14_sameRegs (AOP(left), AOP(result));
6955
6956     offr = shCount / 8;
6957     shCount = shCount & 0x07;
6958
6959     size -= offr;
6960
6961     if (size)
6962     {
6963         switch (shCount)
6964         {
6965         case 0: /* takes 0 or 2N cycles (for offr==0) */
6966             if (!same || offr) {
6967                 for (i=0; i < size; i++)
6968                     movLeft2Result (left, i + offr, result, i);
6969             } // if
6970             break;
6971
6972         case 1: /* takes 1N+1(3) or 2N+1(3) cycles (or offr==0) */
6973             emitpComment ("%s:%d: shCount=%d, size=%d, sign=%d, same=%d, offr=%d", __FUNCTION__, __LINE__, shCount, size, sign, same, offr);
6974             if (same && offr) {
6975                 shiftRight_Left2ResultLit (left, result, 8 * offr, sign);
6976                 shiftRight_Left2ResultLit (result, result, shCount, sign);
6977                 return; /* prevent sign-extending result again */
6978             } else {
6979                 emitCLRC;
6980                 if (sign) {
6981                     emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP(left), AOP_SIZE(left)-1, FALSE, FALSE), 7, 0));
6982                     emitSETC;
6983                 }
6984                 for (i = size-1; i >= 0; i--) {
6985                     if (same && !offr) {
6986                         emitpcode (POC_RRF, popGet (AOP(left), i));
6987                     } else {
6988                         emitpcode (POC_RRFW, popGet (AOP(left), i + offr));
6989                         emitpcode (POC_MOVWF, popGet (AOP(result), i));
6990                     }
6991                 } // for i
6992             } // if (offr)
6993             break;
6994
6995         case 4: /* takes 3(6)+5(N-1) = 5N-2(+1) cycles (for offr==0) */
6996             /* works in-place/with offr as well */
6997             emitpcode (POC_SWAPFW, popGet (AOP(left), offr));
6998             emitpcode (POC_ANDLW, popGetLit (0x0F));
6999             emitpcode (POC_MOVWF, popGet(AOP(result), 0));
7000
7001             for (i = 1; i < size; i++)
7002             {
7003                 emitpcode (POC_SWAPFW, popGet (AOP(left), i + offr));
7004                 emitpcode (POC_MOVWF, popGet (AOP(result), i));
7005                 emitpcode (POC_ANDLW, popGetLit (0xF0));
7006                 emitpcode (POC_IORWF, popGet (AOP(result), i - 1));
7007                 emitpcode (POC_XORWF, popGet (AOP(result), i));
7008             } // for i
7009
7010             if (sign)
7011             {
7012                 emitpcode (POC_MOVLW, popGetLit (0xF0));
7013                 emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP(result), size-1, FALSE, FALSE), 3, 0));
7014                 emitpcode (POC_IORWF, popGet (AOP(result), size-1));
7015             } // if
7016             break;
7017
7018         case 7: /* takes 2(N-1)+3(4) = 2N+1(2) cycles */
7019             /* works in-place/with offr as well */
7020             emitpcode (POC_RLFW, popGet (AOP(left), offr));
7021             for (i = 0; i < size-1; i++) {
7022                 emitpcode (POC_RLFW, popGet (AOP(left), offr + i + 1));
7023                 emitpcode (POC_MOVWF, popGet (AOP(result), i));
7024             } // for i
7025             emitpcode (POC_CLRF, popGet (AOP(result), size-1));
7026             if (!sign) {
7027                 emitpcode (POC_RLF, popGet (AOP(result), size-1));
7028             } else {
7029                 emitSKPNC;
7030                 emitpcode (POC_DECF, popGet (AOP(result), size-1));
7031             }
7032             break;
7033
7034         default:
7035             shiftRight_Left2ResultLit (left, result, offr * 8 + shCount-1, sign);
7036             shiftRight_Left2ResultLit (result, result, 1, sign);
7037             return; /* prevent sign extending result again */
7038             break;
7039         } // switch
7040     } // if
7041
7042     addSign (result, size, sign);
7043 }
7044
7045 #if 0
7046 /*-----------------------------------------------------------------*/
7047 /* shiftL2Left2Result - shift left two bytes from left to result   */
7048 /*-----------------------------------------------------------------*/
7049 static void shiftL2Left2Result (operand *left, int offl,
7050                                 operand *result, int offr, int shCount)
7051 {
7052     FENTRY;
7053
7054     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7055
7056     if(pic14_sameRegs(AOP(result), AOP(left))) {
7057         switch(shCount) {
7058         case 0:
7059             break;
7060         case 1:
7061         case 2:
7062         case 3:
7063
7064             emitpcode(POC_MOVFW,popGet(AOP(result),offr));
7065             emitpcode(POC_ADDWF,popGet(AOP(result),offr));
7066             emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
7067
7068             while(--shCount) {
7069                 emitCLRC;
7070                 emitpcode(POC_RLF, popGet(AOP(result),offr));
7071                 emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
7072             }
7073
7074             break;
7075         case 4:
7076         case 5:
7077             emitpcode(POC_MOVLW, popGetLit(0x0f));
7078             emitpcode(POC_ANDWF, popGet(AOP(result),offr+MSB16));
7079             emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
7080             emitpcode(POC_SWAPF, popGet(AOP(result),offr));
7081             emitpcode(POC_ANDFW, popGet(AOP(result),offr));
7082             emitpcode(POC_XORWF, popGet(AOP(result),offr));
7083             emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
7084             if(shCount >=5) {
7085                 emitpcode(POC_RLF, popGet(AOP(result),offr));
7086                 emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
7087             }
7088             break;
7089         case 6:
7090             emitpcode(POC_RRF,  popGet(AOP(result),offr+MSB16));
7091             emitpcode(POC_RRF,  popGet(AOP(result),offr));
7092             emitpcode(POC_RRF,  popGet(AOP(result),offr+MSB16));
7093             emitpcode(POC_RRF,  popGet(AOP(result),offr));
7094             emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
7095             emitpcode(POC_ANDLW,popGetLit(0xc0));
7096             emitpcode(POC_XORFW,popGet(AOP(result),offr));
7097             emitpcode(POC_XORWF,popGet(AOP(result),offr));
7098             emitpcode(POC_XORFW,popGet(AOP(result),offr));
7099             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7100             break;
7101         case 7:
7102             emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
7103             emitpcode(POC_RRFW, popGet(AOP(result),offr));
7104             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7105             emitpcode(POC_CLRF, popGet(AOP(result),offr));
7106             emitpcode(POC_RRF,  popGet(AOP(result),offr));
7107         }
7108
7109     } else {
7110         switch(shCount) {
7111         case 0:
7112             break;
7113         case 1:
7114         case 2:
7115         case 3:
7116         /* note, use a mov/add for the shift since the mov has a
7117             chance of getting optimized out */
7118             emitpcode(POC_MOVFW, popGet(AOP(left),offl));
7119             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
7120             emitpcode(POC_ADDWF, popGet(AOP(result),offr));
7121             emitpcode(POC_RLFW,  popGet(AOP(left),offl+MSB16));
7122             emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
7123
7124             while(--shCount) {
7125                 emitCLRC;
7126                 emitpcode(POC_RLF, popGet(AOP(result),offr));
7127                 emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
7128             }
7129             break;
7130
7131         case 4:
7132         case 5:
7133             emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
7134             emitpcode(POC_ANDLW, popGetLit(0xF0));
7135             emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
7136             emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
7137             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
7138             emitpcode(POC_ANDLW, popGetLit(0xF0));
7139             emitpcode(POC_XORWF, popGet(AOP(result),offr));
7140             emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
7141
7142
7143             if(shCount == 5) {
7144                 emitpcode(POC_RLF, popGet(AOP(result),offr));
7145                 emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
7146             }
7147             break;
7148         case 6:
7149             emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
7150             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7151             emitpcode(POC_RRFW, popGet(AOP(result),offl));
7152             emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
7153
7154             emitpcode(POC_RRF,  popGet(AOP(result),offr+MSB16));
7155             emitpcode(POC_RRF,  popGet(AOP(result),offr));
7156             emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
7157             emitpcode(POC_ANDLW,popGetLit(0xc0));
7158             emitpcode(POC_XORFW,popGet(AOP(result),offr));
7159             emitpcode(POC_XORWF,popGet(AOP(result),offr));
7160             emitpcode(POC_XORFW,popGet(AOP(result),offr));
7161             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7162             break;
7163         case 7:
7164             emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
7165             emitpcode(POC_RRFW, popGet(AOP(left),offl));
7166             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7167             emitpcode(POC_CLRF, popGet(AOP(result),offr));
7168             emitpcode(POC_RRF,  popGet(AOP(result),offr));
7169         }
7170     }
7171
7172 }
7173
7174 /*-----------------------------------------------------------------*/
7175 /* shiftR2Left2Result - shift right two bytes from left to result  */
7176 /*-----------------------------------------------------------------*/
7177 static void shiftR2Left2Result (operand *left, int offl,
7178                                 operand *result, int offr,
7179                                 int shCount, int sign)
7180 {
7181     int same=0;
7182
7183     FENTRY;
7184     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7185     same = pic14_sameRegs(AOP(result), AOP(left));
7186
7187     if(same && ((offl + MSB16) == offr)){
7188         same=1;
7189         /* don't crash result[offr] */
7190         MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
7191         pic14_emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
7192     }
7193     /* else {
7194     movLeft2Result(left,offl, result, offr);
7195     MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
7196     }
7197     */
7198     /* a:x >> shCount (x = lsb(result))*/
7199     /*
7200     if(sign)
7201     AccAXRshS( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
7202     else {
7203     AccAXRsh( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
7204     */
7205     switch(shCount) {
7206     case 0:
7207         break;
7208     case 1:
7209     case 2:
7210     case 3:
7211         if(sign)
7212             emitpcode(POC_RLFW,popGet(AOP(left),offl+MSB16));
7213         else
7214             emitCLRC;
7215
7216         if(same) {
7217             emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
7218             emitpcode(POC_RRF,popGet(AOP(result),offr));
7219         } else {
7220             emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
7221             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7222             emitpcode(POC_RRFW, popGet(AOP(left),offl));
7223             emitpcode(POC_MOVWF,popGet(AOP(result),offr));
7224         }
7225
7226         while(--shCount) {
7227             if(sign)
7228                 emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
7229             else
7230                 emitCLRC;
7231             emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
7232             emitpcode(POC_RRF,popGet(AOP(result),offr));
7233         }
7234         break;
7235     case 4:
7236     case 5:
7237         if(same) {
7238
7239             emitpcode(POC_MOVLW, popGetLit(0xf0));
7240             emitpcode(POC_ANDWF, popGet(AOP(result),offr));
7241             emitpcode(POC_SWAPF, popGet(AOP(result),offr));
7242
7243             emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
7244             emitpcode(POC_ANDFW, popGet(AOP(result),offr+MSB16));
7245             emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
7246             emitpcode(POC_ADDWF, popGet(AOP(result),offr));
7247         } else {
7248             emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
7249             emitpcode(POC_ANDLW, popGetLit(0x0f));
7250             emitpcode(POC_MOVWF, popGet(AOP(result),offr));
7251
7252             emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
7253             emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
7254             emitpcode(POC_ANDLW, popGetLit(0xf0));
7255             emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
7256             emitpcode(POC_ADDWF, popGet(AOP(result),offr));
7257         }
7258
7259         if(shCount >=5) {
7260             emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
7261             emitpcode(POC_RRF, popGet(AOP(result),offr));
7262         }
7263
7264         if(sign) {
7265             emitpcode(POC_MOVLW, popGetLit(0xf0 + (shCount-4)*8 ));
7266             emitpcode(POC_BTFSC,
7267                 newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0));
7268             emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
7269         }
7270
7271         break;
7272
7273     case 6:
7274         if(same) {
7275
7276             emitpcode(POC_RLF,  popGet(AOP(result),offr));
7277             emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
7278
7279             emitpcode(POC_RLF,  popGet(AOP(result),offr));
7280             emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
7281             emitpcode(POC_RLFW, popGet(AOP(result),offr));
7282             emitpcode(POC_ANDLW,popGetLit(0x03));
7283             if(sign) {
7284                 emitpcode(POC_BTFSC,
7285                     newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0));
7286                 emitpcode(POC_IORLW,popGetLit(0xfc));
7287             }
7288             emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
7289             emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16));
7290             emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
7291             emitpcode(POC_MOVWF,popGet(AOP(result),offr));
7292         } else {
7293             emitpcode(POC_RLFW, popGet(AOP(left),offl));
7294             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7295             emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
7296             emitpcode(POC_MOVWF,popGet(AOP(result),offr));
7297             emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
7298             emitpcode(POC_RLF,  popGet(AOP(result),offr));
7299             emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
7300             emitpcode(POC_ANDLW,popGetLit(0x03));
7301             if(sign) {
7302                 emitpcode(POC_BTFSC,
7303                     newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
7304                 emitpcode(POC_IORLW,popGetLit(0xfc));
7305             }
7306             emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
7307             //emitpcode(POC_RLF,  popGet(AOP(result),offr));
7308
7309
7310         }
7311
7312         break;
7313     case 7:
7314         emitpcode(POC_RLFW, popGet(AOP(left),offl));
7315         emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
7316         emitpcode(POC_MOVWF,popGet(AOP(result),offr));
7317         emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16));
7318         if(sign) {
7319             emitSKPNC;
7320             emitpcode(POC_DECF, popGet(AOP(result),offr+MSB16));
7321         } else
7322             emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
7323   }
7324 }
7325
7326 /*-----------------------------------------------------------------*/
7327 /* shiftLLeftOrResult - shift left one byte from left, or to result*/
7328 /*-----------------------------------------------------------------*/
7329 static void shiftLLeftOrResult (operand *left, int offl,
7330                                 operand *result, int offr, int shCount)
7331 {
7332     FENTRY;
7333     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7334
7335     /* shift left accumulator */
7336     AccLsh(left,offl,shCount);
7337     /* or with result */
7338     emitpcode (POC_IORWF, popGet (AOP(result), offr));
7339     assert ( !"broken (modifies left, fails for left==result))" );
7340 }
7341
7342 /*-----------------------------------------------------------------*/
7343 /* shiftRLeftOrResult - shift right one byte from left,or to result*/
7344 /*-----------------------------------------------------------------*/
7345 static void shiftRLeftOrResult (operand *left, int offl,
7346                                 operand *result, int offr, int shCount)
7347 {
7348     FENTRY;
7349     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7350
7351     /* shift right accumulator */
7352     AccRsh(left,offl,shCount);
7353     /* or with result */
7354     emitpcode (POC_IORWF, popGet (AOP(result), offr));
7355     assert ( !"broken (modifies left, fails for left==result))" );
7356 }
7357
7358 /*-----------------------------------------------------------------*/
7359 /* genlshOne - left shift a one byte quantity by known count       */
7360 /*-----------------------------------------------------------------*/
7361 static void genlshOne (operand *result, operand *left, int shCount)
7362 {
7363     FENTRY;
7364     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7365     shiftL1Left2Result(left, LSB, result, LSB, shCount);
7366 }
7367
7368 /*-----------------------------------------------------------------*/
7369 /* genlshTwo - left shift two bytes by known amount != 0           */
7370 /*-----------------------------------------------------------------*/
7371 static void genlshTwo (operand *result,operand *left, int shCount)
7372 {
7373     int size;
7374
7375     FENTRY;
7376     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7377     size = pic14_getDataSize(result);
7378
7379     /* if shCount >= 8 */
7380     if (shCount >= 8) {
7381         shCount -= 8 ;
7382
7383         if (size > 1){
7384             if (shCount)
7385                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
7386             else
7387                 movLeft2Result(left, LSB, result, MSB16);
7388         }
7389         emitpcode(POC_CLRF,popGet(AOP(result),LSB));
7390     }
7391
7392     /*  1 <= shCount <= 7 */
7393     else {
7394         if(size == 1)
7395             shiftL1Left2Result(left, LSB, result, LSB, shCount);
7396         else
7397             shiftL2Left2Result(left, LSB, result, LSB, shCount);
7398     }
7399 }
7400
7401 /*-----------------------------------------------------------------*/
7402 /* shiftLLong - shift left one long from left to result            */
7403 /* offl = LSB or MSB16                                             */
7404 /*-----------------------------------------------------------------*/
7405 static void shiftLLong (operand *left, operand *result, int offr )
7406 {
7407     char *l;
7408     int size = AOP_SIZE(result);
7409
7410     FENTRY;
7411     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7412     if(size >= LSB+offr){
7413         l = aopGet(AOP(left),LSB,FALSE,FALSE);
7414         MOVA(l);
7415         pic14_emitcode("add","a,acc");
7416         if (pic14_sameRegs(AOP(left),AOP(result)) &&
7417             size >= MSB16+offr && offr != LSB )
7418             pic14_emitcode("xch","a,%s",
7419             aopGet(AOP(left),LSB+offr,FALSE,FALSE));
7420         else
7421             aopPut(AOP(result),"a",LSB+offr);
7422     }
7423
7424     if(size >= MSB16+offr){
7425         if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) {
7426             l = aopGet(AOP(left),MSB16,FALSE,FALSE);
7427             MOVA(l);
7428         }
7429         pic14_emitcode("rlc","a");
7430         if (pic14_sameRegs(AOP(left),AOP(result)) &&
7431             size >= MSB24+offr && offr != LSB)
7432             pic14_emitcode("xch","a,%s",
7433             aopGet(AOP(left),MSB16+offr,FALSE,FALSE));
7434         else
7435             aopPut(AOP(result),"a",MSB16+offr);
7436     }
7437
7438     if(size >= MSB24+offr){
7439         if (!(pic14_sameRegs(AOP(left),AOP(left)) && size >= MSB24+offr && offr != LSB)) {
7440             l = aopGet(AOP(left),MSB24,FALSE,FALSE);
7441             MOVA(l);
7442         }
7443         pic14_emitcode("rlc","a");
7444         if (pic14_sameRegs(AOP(left),AOP(result)) &&
7445             size >= MSB32+offr && offr != LSB )
7446             pic14_emitcode("xch","a,%s",
7447             aopGet(AOP(left),MSB24+offr,FALSE,FALSE));
7448         else
7449             aopPut(AOP(result),"a",MSB24+offr);
7450     }
7451
7452     if(size > MSB32+offr){
7453         if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB32+offr && offr != LSB)) {
7454             l = aopGet(AOP(left),MSB32,FALSE,FALSE);
7455             MOVA(l);
7456         }
7457         pic14_emitcode("rlc","a");
7458         aopPut(AOP(result),"a",MSB32+offr);
7459     }
7460     if(offr != LSB)
7461         aopPut(AOP(result),zero,LSB);
7462 }
7463
7464 /*-----------------------------------------------------------------*/
7465 /* genlshFour - shift four byte by a known amount != 0             */
7466 /*-----------------------------------------------------------------*/
7467 static void genlshFour (operand *result, operand *left, int shCount)
7468 {
7469     int size;
7470
7471     FENTRY;
7472     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7473     size = AOP_SIZE(result);
7474
7475     /* if shifting more that 3 bytes */
7476     if (shCount >= 24 ) {
7477         shCount -= 24;
7478         if (shCount)
7479         /* lowest order of left goes to the highest
7480         order of the destination */
7481         shiftL1Left2Result(left, LSB, result, MSB32, shCount);
7482         else
7483             movLeft2Result(left, LSB, result, MSB32);
7484         aopPut(AOP(result),zero,LSB);
7485         aopPut(AOP(result),zero,MSB16);
7486         aopPut(AOP(result),zero,MSB32);
7487         return;
7488     }
7489
7490     /* more than two bytes */
7491     else if ( shCount >= 16 ) {
7492         /* lower order two bytes goes to higher order two bytes */
7493         shCount -= 16;
7494         /* if some more remaining */
7495         if (shCount)
7496             shiftL2Left2Result(left, LSB, result, MSB24, shCount);
7497         else {
7498             movLeft2Result(left, MSB16, result, MSB32);
7499             movLeft2Result(left, LSB, result, MSB24);
7500         }
7501         aopPut(AOP(result),zero,MSB16);
7502         aopPut(AOP(result),zero,LSB);
7503         return;
7504     }
7505
7506     /* if more than 1 byte */
7507     else if ( shCount >= 8 ) {
7508         /* lower order three bytes goes to higher order  three bytes */
7509         shCount -= 8;
7510         if(size == 2){
7511             if(shCount)
7512                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
7513             else
7514                 movLeft2Result(left, LSB, result, MSB16);
7515         }
7516         else{   /* size = 4 */
7517             if(shCount == 0){
7518                 movLeft2Result(left, MSB24, result, MSB32);
7519                 movLeft2Result(left, MSB16, result, MSB24);
7520                 movLeft2Result(left, LSB, result, MSB16);
7521                 aopPut(AOP(result),zero,LSB);
7522             }
7523             else if(shCount == 1)
7524                 shiftLLong(left, result, MSB16);
7525             else{
7526                 shiftL2Left2Result(left, MSB16, result, MSB24, shCount);
7527                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
7528                 shiftRLeftOrResult(left, LSB, result, MSB24, 8 - shCount);
7529                 aopPut(AOP(result),zero,LSB);
7530             }
7531         }
7532     }
7533
7534     /* 1 <= shCount <= 7 */
7535     else if(shCount <= 2){
7536         shiftLLong(left, result, LSB);
7537         if(shCount == 2)
7538             shiftLLong(result, result, LSB);
7539     }
7540     /* 3 <= shCount <= 7, optimize */
7541     else{
7542         shiftL2Left2Result(left, MSB24, result, MSB24, shCount);
7543         shiftRLeftOrResult(left, MSB16, result, MSB24, 8 - shCount);
7544         shiftL2Left2Result(left, LSB, result, LSB, shCount);
7545     }
7546 }
7547 #endif
7548
7549 #if 0
7550 /*-----------------------------------------------------------------*/
7551 /* genLeftShiftLiteral - left shifting by known count              */
7552 /*-----------------------------------------------------------------*/
7553 static void genLeftShiftLiteral (operand *left,
7554                                  operand *right,
7555                                  operand *result,
7556                                  iCode *ic)
7557 {
7558     int shCount = (int) ulFromVal (AOP(right)->aopu.aop_lit);
7559     //int size;
7560
7561     FENTRY;
7562     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7563     freeAsmop(right,NULL,ic,TRUE);
7564
7565     aopOp(left,ic,FALSE);
7566     aopOp(result,ic,FALSE);
7567
7568     size = getSize(operandType(result));
7569
7570 #if VIEW_SIZE
7571     pic14_emitcode("; shift left ","result %d, left %d",size,
7572         AOP_SIZE(left));
7573 #endif
7574
7575     /* I suppose that the left size >= result size */
7576     if(shCount == 0){
7577         while(size--){
7578             movLeft2Result(left, size, result, size);
7579         }
7580     }
7581
7582     else if(shCount >= (size * 8))
7583         while(size--)
7584             aopPut(AOP(result),zero,size);
7585         else{
7586             switch (size) {
7587             case 1:
7588                 genlshOne (result,left,shCount);
7589                 break;
7590
7591             case 2:
7592             case 3:
7593                 genlshTwo (result,left,shCount);
7594                 break;
7595
7596             case 4:
7597                 genlshFour (result,left,shCount);
7598                 break;
7599             }
7600         }
7601         freeAsmop(left,NULL,ic,TRUE);
7602         freeAsmop(result,NULL,ic,TRUE);
7603 }
7604 #endif
7605
7606 /*-----------------------------------------------------------------*
7607 * genMultiAsm - repeat assembly instruction for size of register.
7608 * if endian == 1, then the high byte (i.e base address + size of
7609 * register) is used first else the low byte is used first;
7610 *-----------------------------------------------------------------*/
7611 static void genMultiAsm( PIC_OPCODE poc, operand *reg, int size, int endian)
7612 {
7613
7614     int offset = 0;
7615
7616     FENTRY;
7617     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7618
7619     if(!reg)
7620         return;
7621
7622     if(!endian) {
7623         endian = 1;
7624     } else {
7625         endian = -1;
7626         offset = size-1;
7627     }
7628
7629     while(size--) {
7630         emitpcode(poc,    popGet(AOP(reg),offset));
7631         offset += endian;
7632     }
7633
7634 }
7635
7636 #if 0
7637 /*-----------------------------------------------------------------*/
7638 /* genLeftShift - generates code for left shifting                 */
7639 /*-----------------------------------------------------------------*/
7640 static void genLeftShift (iCode *ic)
7641 {
7642     operand *left,*right, *result;
7643     int size, offset;
7644     unsigned long lit = 0L;
7645     char *l;
7646     symbol *tlbl , *tlbl1;
7647     pCodeOp *pctemp;
7648
7649     FENTRY;
7650     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7651
7652     right = IC_RIGHT(ic);
7653     left  = IC_LEFT(ic);
7654     result = IC_RESULT(ic);
7655
7656     aopOp(right,ic,FALSE);
7657     aopOp(left,ic,FALSE);
7658     aopOp(result,ic,FALSE);
7659
7660
7661     /* if the shift count is known then do it
7662     as efficiently as possible */
7663     if (AOP_TYPE(right) == AOP_LIT) {
7664         shiftLeft_Left2ResultLit (left, result, (int) ulFromVal (AOP(right)->aopu.aop_lit));
7665         return ;
7666     }
7667
7668     /* shift count is unknown then we have to form
7669     a loop get the loop count in B : Note: we take
7670     only the lower order byte since shifting
7671     more that 32 bits make no sense anyway, ( the
7672     largest size of an object can be only 32 bits ) */
7673
7674     /* this code fails for RIGHT == RESULT */
7675     assert (!pic14_sameRegs (AOP(right), AOP(result)));
7676
7677     /* now move the left to the result if they are not the
7678     same */
7679     if (!pic14_sameRegs(AOP(left),AOP(result)) &&
7680         AOP_SIZE(result) > 1) {
7681
7682         size = AOP_SIZE(result);
7683         offset=0;
7684         while (size--) {
7685             l = aopGet(AOP(left),offset,FALSE,TRUE);
7686             if (*l == '@' && (IS_AOP_PREG(result))) {
7687
7688                 pic14_emitcode("mov","a,%s",l);
7689                 aopPut(AOP(result),"a",offset);
7690             } else {
7691                 emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
7692                 emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
7693                 //aopPut(AOP(result),l,offset);
7694             }
7695             offset++;
7696         }
7697     }
7698
7699     if(AOP_TYPE(left) == AOP_LIT)
7700         lit = ulFromVal (AOP(left)->aopu.aop_lit);
7701
7702     size = AOP_SIZE(result);
7703
7704     /* if it is only one byte then */
7705     if (size == 1) {
7706         if(optimized_for_speed && AOP_TYPE(left)!=AOP_LIT) {
7707             emitpcode(POC_SWAPFW, popGet(AOP(left),0));
7708             emitpcode(POC_ANDLW,  popGetLit(0xf0));
7709             emitpcode(POC_BTFSS,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
7710             emitpcode(POC_MOVFW,  popGet(AOP(left),0));
7711             emitpcode(POC_MOVWF,  popGet(AOP(result),0));
7712             emitpcode(POC_BTFSS,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
7713             emitpcode(POC_ADDWF,  popGet(AOP(result),0));
7714             emitpcode(POC_RLFW,   popGet(AOP(result),0));
7715             emitpcode(POC_ANDLW,  popGetLit(0xfe));
7716             emitpcode(POC_ADDFW,  popGet(AOP(result),0));
7717             emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
7718             emitpcode(POC_ADDWF,  popGet(AOP(result),0));
7719         } else {
7720
7721             tlbl = newiTempLabel(NULL);
7722             if (!pic14_sameRegs(AOP(left),AOP(result))) {
7723                 mov2w (AOP(left), 0);
7724                 emitpcode(POC_MOVWF,  popGet(AOP(result),0));
7725             }
7726
7727             emitpcode(POC_COMFW,  popGet(AOP(right),0));
7728             emitpcode(POC_RRF,    popGet(AOP(result),0));
7729             emitpLabel(tlbl->key);
7730             emitpcode(POC_RLF,    popGet(AOP(result),0));
7731             emitpcode(POC_ADDLW,  popGetLit(1));
7732             emitSKPC;
7733             emitpcode(POC_GOTO,popGetLabel(tlbl->key));
7734         }
7735         goto release ;
7736     }
7737
7738     if (pic14_sameRegs(AOP(left),AOP(result))) {
7739
7740         tlbl = newiTempLabel(NULL);
7741         emitpcode(POC_COMFW,  popGet(AOP(right),0));
7742         genMultiAsm(POC_RRF, result, size,1);
7743         emitpLabel(tlbl->key);
7744         genMultiAsm(POC_RLF, result, size,0);
7745         emitpcode(POC_ADDLW,  popGetLit(1));
7746         emitSKPC;
7747         emitpcode(POC_GOTO,popGetLabel(tlbl->key));
7748         goto release;
7749     }
7750
7751     //tlbl = newiTempLabel(NULL);
7752     //offset = 0 ;
7753     //tlbl1 = newiTempLabel(NULL);
7754
7755     //reAdjustPreg(AOP(result));
7756
7757     //pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
7758     //pic14_emitcode("","%05d_DS_:",tlbl->key+100);
7759     //l = aopGet(AOP(result),offset,FALSE,FALSE);
7760     //MOVA(l);
7761     //pic14_emitcode("add","a,acc");
7762     //aopPut(AOP(result),"a",offset++);
7763     //while (--size) {
7764     //  l = aopGet(AOP(result),offset,FALSE,FALSE);
7765     //  MOVA(l);
7766     //  pic14_emitcode("rlc","a");
7767     //  aopPut(AOP(result),"a",offset++);
7768     //}
7769     //reAdjustPreg(AOP(result));
7770
7771     //pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
7772     //pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
7773
7774
7775     tlbl = newiTempLabel(NULL);
7776     tlbl1= newiTempLabel(NULL);
7777
7778     size = AOP_SIZE(result);
7779     offset = 1;
7780
7781     pctemp = popGetTempReg();  /* grab a temporary working register. */
7782
7783     emitpcode(POC_MOVFW, popGet(AOP(right),0));
7784
7785     /* offset should be 0, 1 or 3 */
7786     emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
7787     emitSKPNZ;
7788     emitpcode(POC_GOTO,  popGetLabel(tlbl1->key));
7789
7790     emitpcode(POC_MOVWF, pctemp);
7791
7792
7793     emitpLabel(tlbl->key);
7794
7795     emitCLRC;
7796     emitpcode(POC_RLF,  popGet(AOP(result),0));
7797     while(--size)
7798         emitpcode(POC_RLF,   popGet(AOP(result),offset++));
7799
7800     emitpcode(POC_DECFSZ,  pctemp);
7801     emitpcode(POC_GOTO,popGetLabel(tlbl->key));
7802     emitpLabel(tlbl1->key);
7803
7804     popReleaseTempReg(pctemp);
7805
7806
7807 release:
7808     freeAsmop (right,NULL,ic,TRUE);
7809     freeAsmop(left,NULL,ic,TRUE);
7810     freeAsmop(result,NULL,ic,TRUE);
7811 }
7812 #endif
7813
7814 #if 0
7815 /*-----------------------------------------------------------------*/
7816 /* genrshOne - right shift a one byte quantity by known count      */
7817 /*-----------------------------------------------------------------*/
7818 static void genrshOne (operand *result, operand *left,
7819                        int shCount, int sign)
7820 {
7821     FENTRY;
7822     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7823     shiftR1Left2Result(left, LSB, result, LSB, shCount, sign);
7824 }
7825
7826 /*-----------------------------------------------------------------*/
7827 /* genrshTwo - right shift two bytes by known amount != 0          */
7828 /*-----------------------------------------------------------------*/
7829 static void genrshTwo (operand *result,operand *left,
7830                        int shCount, int sign)
7831 {
7832     FENTRY;
7833     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7834     /* if shCount >= 8 */
7835     if (shCount >= 8) {
7836         shCount -= 8 ;
7837         if (shCount)
7838             shiftR1Left2Result(left, MSB16, result, LSB,
7839             shCount, sign);
7840         else
7841             movLeft2Result(left, MSB16, result, LSB);
7842
7843         emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
7844
7845         if(sign) {
7846             emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
7847             emitpcode(POC_DECF, popGet(AOP(result),MSB16));
7848         }
7849     }
7850
7851     /*  1 <= shCount <= 7 */
7852     else
7853         shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
7854 }
7855
7856 /*-----------------------------------------------------------------*/
7857 /* shiftRLong - shift right one long from left to result           */
7858 /* offl = LSB or MSB16                                             */
7859 /*-----------------------------------------------------------------*/
7860 static void shiftRLong (operand *left, int offl,
7861                         operand *result, int sign)
7862 {
7863     int size, same;
7864
7865     FENTRY;
7866     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7867
7868     size = AOP_SIZE(left);
7869     if (AOP_SIZE(result) < size) size = AOP_SIZE(result);
7870
7871     if (sign)
7872         emitpcode (POC_RLFW, popGet (AOP(left), AOP_SIZE(left)-1));
7873     else
7874         emitCLRC;
7875
7876     assert (offl >= 0 && offl < size);
7877
7878     same = pic14_sameRegs (AOP(left), AOP(result));
7879
7880     /* perform the shift */
7881     while (size--)
7882     {
7883         if (same && !offl) {
7884             emitpcode (POC_RRF, popGet (AOP(result), size));
7885         } else {
7886             emitpcode (POC_RRFW, popGet (AOP(left), size));
7887             emitpcode (POC_MOVWF, popGet (AOP(result), size-offl));
7888         }
7889     } // while
7890
7891     addSign (result, AOP_SIZE(left) - offl, sign);
7892 }
7893
7894 /*-----------------------------------------------------------------*/
7895 /* genrshFour - shift four byte by a known amount != 0             */
7896 /*-----------------------------------------------------------------*/
7897 static void genrshFour (operand *result, operand *left,
7898                         int shCount, int sign)
7899 {
7900     FENTRY;
7901     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7902     /* if shifting more that 3 bytes */
7903     if(shCount >= 24 ) {
7904         shCount -= 24;
7905         if(shCount)
7906             shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
7907         else
7908             movLeft2Result(left, MSB32, result, LSB);
7909
7910         addSign(result, MSB16, sign);
7911     }
7912     else if(shCount >= 16){
7913         shCount -= 16;
7914         if(shCount)
7915             shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
7916         else{
7917             movLeft2Result(left, MSB24, result, LSB);
7918             movLeft2Result(left, MSB32, result, MSB16);
7919         }
7920         addSign(result, MSB24, sign);
7921     }
7922     else if(shCount >= 8){
7923         shCount -= 8;
7924         if(shCount == 1)
7925             shiftRLong(left, MSB16, result, sign);
7926         else if(shCount == 0){
7927             movLeft2Result(left, MSB16, result, LSB);
7928             movLeft2Result(left, MSB24, result, MSB16);
7929             movLeft2Result(left, MSB32, result, MSB24);
7930             addSign(result, MSB32, sign);
7931         }
7932         else{
7933             shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0);
7934             shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount);
7935             /* the last shift is signed */
7936             shiftR1Left2Result(left, MSB32, result, MSB24, shCount, sign);
7937             addSign(result, MSB32, sign);
7938         }
7939     }
7940     else{   /* 1 <= shCount <= 7 */
7941         if(shCount <= 2){
7942             shiftRLong(left, LSB, result, sign);
7943             if(shCount == 2)
7944                 shiftRLong(result, LSB, result, sign);
7945         }
7946         else{
7947             shiftR2Left2Result(left, LSB, result, LSB, shCount, 0);
7948             shiftLLeftOrResult(left, MSB24, result, MSB16, 8 - shCount);
7949             shiftR2Left2Result(left, MSB24, result, MSB24, shCount, sign);
7950         }
7951     }
7952 }
7953
7954 /*-----------------------------------------------------------------*/
7955 /* genRightShiftLiteral - right shifting by known count            */
7956 /*-----------------------------------------------------------------*/
7957 static void genRightShiftLiteral (operand *left,
7958                                   operand *right,
7959                                   operand *result,
7960                                   iCode *ic,
7961                                   int sign)
7962 {
7963     int shCount = (int) ulFromVal (AOP(right)->aopu.aop_lit);
7964     int lsize,res_size;
7965
7966     FENTRY;
7967     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
7968     freeAsmop(right,NULL,ic,TRUE);
7969
7970     aopOp(left,ic,FALSE);
7971     aopOp(result,ic,FALSE);
7972
7973 #if VIEW_SIZE
7974     pic14_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
7975         AOP_SIZE(left));
7976 #endif
7977
7978     lsize = pic14_getDataSize(left);
7979     res_size = pic14_getDataSize(result);
7980     /* test the LEFT size !!! */
7981
7982     /* I suppose that the left size >= result size */
7983     if(shCount == 0){
7984         while(res_size--)
7985             movLeft2Result(left, res_size, result, res_size);
7986     }
7987
7988     else if(shCount >= (lsize * 8)){
7989
7990         if(res_size == 1) {
7991             emitpcode(POC_CLRF, popGet(AOP(result),LSB));
7992             if(sign) {
7993                 emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
7994                 emitpcode(POC_DECF, popGet(AOP(result),LSB));
7995             }
7996         } else {
7997
7998             if(sign) {
7999                 emitpcode(POC_MOVLW, popGetLit(0));
8000                 emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
8001                 emitpcode(POC_MOVLW, popGetLit(0xff));
8002                 while(res_size--)
8003                     emitpcode(POC_MOVWF, popGet(AOP(result),res_size));
8004
8005             } else {
8006
8007                 while(res_size--)
8008                     emitpcode(POC_CLRF, popGet(AOP(result),res_size));
8009             }
8010         }
8011     } else {
8012
8013         switch (res_size) {
8014         case 1:
8015             genrshOne (result,left,shCount,sign);
8016             break;
8017
8018         case 2:
8019             genrshTwo (result,left,shCount,sign);
8020             break;
8021
8022         case 4:
8023             genrshFour (result,left,shCount,sign);
8024             break;
8025         default :
8026             break;
8027         }
8028
8029     }
8030
8031     freeAsmop(left,NULL,ic,TRUE);
8032     freeAsmop(result,NULL,ic,TRUE);
8033 }
8034 #endif
8035
8036 #if 0
8037 /*-----------------------------------------------------------------*/
8038 /* genSignedRightShift - right shift of signed number              */
8039 /*-----------------------------------------------------------------*/
8040 static void genSignedRightShift (iCode *ic)
8041 {
8042     operand *right, *left, *result;
8043     int size, offset;
8044     //  char *l;
8045     symbol *tlbl, *tlbl1 ;
8046     pCodeOp *pctemp;
8047
8048     //same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
8049
8050     /* we do it the hard way put the shift count in b
8051     and loop thru preserving the sign */
8052     FENTRY;
8053     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8054
8055     right = IC_RIGHT(ic);
8056     left  = IC_LEFT(ic);
8057     result = IC_RESULT(ic);
8058
8059     aopOp(right,ic,FALSE);
8060     aopOp(left,ic,FALSE);
8061     aopOp(result,ic,FALSE);
8062
8063
8064     if ( AOP_TYPE(right) == AOP_LIT) {
8065         shiftRight_Left2ResultLit (left, result, (int) ulFromVal (AOP(right)->aopu.aop_lit), 1);
8066         //genRightShiftLiteral (left,right,result,ic,1);
8067         return ;
8068     }
8069     /* shift count is unknown then we have to form
8070     a loop get the loop count in B : Note: we take
8071     only the lower order byte since shifting
8072     more that 32 bits make no sense anyway, ( the
8073     largest size of an object can be only 32 bits ) */
8074
8075     //pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
8076     //pic14_emitcode("inc","b");
8077     //freeAsmop (right,NULL,ic,TRUE);
8078     //aopOp(left,ic,FALSE);
8079     //aopOp(result,ic,FALSE);
8080
8081     /* now move the left to the result if they are not the
8082     same */
8083     if (!pic14_sameRegs(AOP(left),AOP(result)) &&
8084         AOP_SIZE(result) > 1) {
8085
8086         size = AOP_SIZE(result);
8087         offset=0;
8088         while (size--) {
8089             /*
8090             l = aopGet(AOP(left),offset,FALSE,TRUE);
8091             if (*l == '@' && IS_AOP_PREG(result)) {
8092                 pic14_emitcode("mov","a,%s",l);
8093                 aopPut(AOP(result),"a",offset);
8094             } else
8095             aopPut(AOP(result),l,offset);
8096             */
8097             emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
8098             emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
8099
8100             offset++;
8101         }
8102     }
8103
8104     /* mov the highest order bit to OVR */
8105     tlbl = newiTempLabel(NULL);
8106     tlbl1= newiTempLabel(NULL);
8107
8108     size = AOP_SIZE(result);
8109     offset = size - 1;
8110
8111     pctemp = popGetTempReg();  /* grab a temporary working register. */
8112
8113     emitpcode(POC_MOVFW, popGet(AOP(right),0));
8114
8115     /* offset should be 0, 1 or 3 */
8116     emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
8117     emitSKPNZ;
8118     emitpcode(POC_GOTO,  popGetLabel(tlbl1->key));
8119
8120     emitpcode(POC_MOVWF, pctemp);
8121
8122
8123     emitpLabel(tlbl->key);
8124
8125     emitpcode(POC_RLFW,  popGet(AOP(result),offset));
8126     emitpcode(POC_RRF,   popGet(AOP(result),offset));
8127
8128     while(--size) {
8129         emitpcode(POC_RRF,   popGet(AOP(result),--offset));
8130     }
8131
8132     emitpcode(POC_DECFSZ,  pctemp);
8133     emitpcode(POC_GOTO,popGetLabel(tlbl->key));
8134     emitpLabel(tlbl1->key);
8135
8136     popReleaseTempReg(pctemp);
8137 #if 0
8138     size = AOP_SIZE(result);
8139     offset = size - 1;
8140     pic14_emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE));
8141     pic14_emitcode("rlc","a");
8142     pic14_emitcode("mov","ov,c");
8143     /* if it is only one byte then */
8144     if (size == 1) {
8145         l = aopGet(AOP(left),0,FALSE,FALSE);
8146         MOVA(l);
8147         pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
8148         pic14_emitcode("","%05d_DS_:",tlbl->key+100);
8149         pic14_emitcode("mov","c,ov");
8150         pic14_emitcode("rrc","a");
8151         pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
8152         pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
8153         aopPut(AOP(result),"a",0);
8154         goto release ;
8155     }
8156
8157     reAdjustPreg(AOP(result));
8158     pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
8159     pic14_emitcode("","%05d_DS_:",tlbl->key+100);
8160     pic14_emitcode("mov","c,ov");
8161     while (size--) {
8162         l = aopGet(AOP(result),offset,FALSE,FALSE);
8163         MOVA(l);
8164         pic14_emitcode("rrc","a");
8165         aopPut(AOP(result),"a",offset--);
8166     }
8167     reAdjustPreg(AOP(result));
8168     pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
8169     pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
8170
8171 release:
8172 #endif
8173
8174     freeAsmop(left,NULL,ic,TRUE);
8175     freeAsmop(result,NULL,ic,TRUE);
8176     freeAsmop(right,NULL,ic,TRUE);
8177 }
8178 #endif
8179
8180 /*-----------------------------------------------------------------*/
8181 /* loadSignToC - load the operand's sign bit into CARRY            */
8182 /*-----------------------------------------------------------------*/
8183
8184 static void loadSignToC (operand *op)
8185 {
8186     FENTRY;
8187     assert (op && AOP(op) && AOP_SIZE(op));
8188
8189     emitCLRC;
8190     emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(op),AOP_SIZE(op)-1,FALSE,FALSE),7,0));
8191     emitSETC;
8192 }
8193
8194 /*-----------------------------------------------------------------*/
8195 /* genRightShift - generate code for right shifting                */
8196 /*-----------------------------------------------------------------*/
8197 static void genGenericShift (iCode *ic, int shiftRight)
8198 {
8199     operand *right, *left, *result;
8200     sym_link *retype ;
8201     int size;
8202     symbol *tlbl, *tlbl1, *inverselbl;
8203
8204     FENTRY;
8205     /* if signed then we do it the hard way preserve the
8206     sign bit moving it inwards */
8207     retype = getSpec(operandType(IC_RESULT(ic)));
8208     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8209
8210     /* signed & unsigned types are treated the same : i.e. the
8211     signed is NOT propagated inwards : quoting from the
8212     ANSI - standard : "for E1 >> E2, is equivalent to division
8213     by 2**E2 if unsigned or if it has a non-negative value,
8214     otherwise the result is implementation defined ", MY definition
8215     is that the sign does not get propagated */
8216
8217     right = IC_RIGHT(ic);
8218     left  = IC_LEFT(ic);
8219     result = IC_RESULT(ic);
8220
8221     aopOp(right,ic,FALSE);
8222     aopOp(left,ic,FALSE);
8223     aopOp(result,ic,FALSE);
8224
8225     /* if the shift count is known then do it
8226     as efficiently as possible */
8227     if (AOP_TYPE(right) == AOP_LIT) {
8228         int lit = (int) ulFromVal (AOP(right)->aopu.aop_lit);
8229         if (lit < 0)
8230         {
8231             lit = -lit;
8232             shiftRight = !shiftRight;
8233         }
8234
8235         if (shiftRight)
8236             shiftRight_Left2ResultLit (left, result, lit, !SPEC_USIGN(operandType(left)));
8237         else
8238             shiftLeft_Left2ResultLit (left, result, lit);
8239         //genRightShiftLiteral (left,right,result,ic, 0);
8240         return ;
8241     }
8242
8243     /* shift count is unknown then we have to form
8244     a loop get the loop count in B : Note: we take
8245     only the lower order byte since shifting
8246     more that 32 bits make no sense anyway, ( the
8247     largest size of an object can be only 32 bits ) */
8248
8249     /* we must not overwrite the shift counter */
8250     assert (!pic14_sameRegs(AOP(right),AOP(result)));
8251
8252     /* now move the left to the result if they are not the
8253     same */
8254     if (!pic14_sameRegs(AOP(left),AOP(result)))
8255     {
8256         size = min(AOP_SIZE(result), AOP_SIZE(left));
8257         while (size--) {
8258             mov2w(AOP(left), size);
8259             movwf(AOP(result), size);
8260         }
8261         addSign (result, AOP_SIZE(left), !SPEC_USIGN(operandType(left)));
8262     }
8263
8264     tlbl = newiTempLabel(NULL);
8265     tlbl1= newiTempLabel(NULL);
8266     inverselbl = NULL;
8267     size = AOP_SIZE(result);
8268
8269     mov2w(AOP(right),0);
8270     if (!SPEC_USIGN(operandType(right)))
8271     {
8272         inverselbl = newiTempLabel(NULL);
8273         /* signed shift count -- invert shift direction for c<0 */
8274         emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),7,0));
8275         emitpcode(POC_GOTO, popGetLabel(inverselbl->key));
8276     } // if
8277     emitpcode(POC_SUBLW, popGetLit(0)); /* -count in WREG, 0-x > 0 --> BORROW = !CARRY --> CARRY is clear! */
8278     /* check for `a = b >> c' with `-c == 0' */
8279     emitSKPNZ;
8280     emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
8281     emitpLabel(tlbl->key);
8282     /* propagate the sign bit inwards for SIGNED result */
8283     if (shiftRight && !SPEC_USIGN(operandType(result))) loadSignToC(result);
8284     genMultiAsm(shiftRight ? POC_RRF : POC_RLF, result, size, shiftRight);
8285     emitpcode(POC_ADDLW,  popGetLit(1));    /* clears CARRY (unless W==0 afterwards) */
8286     emitSKPC;
8287     emitpcode(POC_GOTO,popGetLabel(tlbl->key));
8288
8289     if (!SPEC_USIGN(operandType(right)))
8290     {
8291         symbol *inv_loop = newiTempLabel(NULL);
8292
8293         shiftRight = !shiftRight;   /* invert shift direction */
8294
8295         /* we came here from the code above -- we are done */
8296         emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
8297
8298         /* emit code for shifting N<0 steps, count is already in W */
8299         emitpLabel(inverselbl->key);
8300         if (!shiftRight || SPEC_USIGN(operandType(result))) emitCLRC;
8301         emitpLabel(inv_loop->key);
8302         /* propagate the sign bit inwards for SIGNED result */
8303         if (shiftRight && !SPEC_USIGN(operandType(result))) loadSignToC(result);
8304         genMultiAsm(shiftRight ? POC_RRF : POC_RLF, result, size, shiftRight);
8305         emitpcode(POC_ADDLW, popGetLit(1));
8306         emitSKPC;
8307         emitpcode(POC_GOTO, popGetLabel(inv_loop->key));
8308     } // if
8309
8310     emitpLabel(tlbl1->key);
8311
8312     freeAsmop(left,NULL,ic,TRUE);
8313     freeAsmop (right,NULL,ic,TRUE);
8314     freeAsmop(result,NULL,ic,TRUE);
8315 }
8316
8317 static void genRightShift (iCode *ic)
8318 {
8319     genGenericShift(ic, 1);
8320 }
8321
8322 static void genLeftShift (iCode *ic)
8323 {
8324     genGenericShift(ic, 0);
8325 }
8326
8327 /*-----------------------------------------------------------------*/
8328 /* SetIrp - Set IRP bit                                            */
8329 /*-----------------------------------------------------------------*/
8330 void SetIrp(operand *result) {
8331     FENTRY;
8332     if (AOP_TYPE(result) == AOP_LIT) {
8333         unsigned lit = (unsigned) double2ul (operandLitValue(result));
8334         if (lit&0x100)
8335             emitSETIRP;
8336         else
8337             emitCLRIRP;
8338     } else {
8339         if (PCOP(AOP(result))->type == PO_LITERAL) {
8340             int addrs = PCOL(AOP(result))->lit;
8341             if (addrs & 0x100)
8342                 emitSETIRP;
8343             else
8344                 emitCLRIRP;
8345         } else {
8346             emitCLRIRP; /* always ensure this is clear as it may have previouly been set */
8347             if(AOP_SIZE(result) > 1) {
8348                 emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),1,FALSE,FALSE),0,0));
8349                 emitSETIRP;
8350             }
8351         }
8352     }
8353 }
8354
8355 static void
8356 setup_fsr (operand *ptr)
8357 {
8358   mov2w_op(ptr, 0);
8359   emitpcode(POC_MOVWF, popCopyReg (&pc_fsr));
8360
8361   /* also setup-up IRP */
8362   SetIrp (ptr);
8363 }
8364
8365 /*-----------------------------------------------------------------*/
8366 /* emitPtrByteGet - emits code to get a byte into WREG from an     */
8367 /*                  arbitrary pointer (__code, __data, generic)    */
8368 /*-----------------------------------------------------------------*/
8369 static void
8370 emitPtrByteGet (operand *src, int p_type, bool alreadyAddressed)
8371 {
8372     FENTRY;
8373     switch (p_type)
8374     {
8375     case POINTER:
8376     case FPOINTER:
8377       if (!alreadyAddressed) setup_fsr (src);
8378       emitpcode(POC_MOVFW, popCopyReg (&pc_fsr));
8379       break;
8380
8381     case CPOINTER:
8382       assert( AOP_SIZE(src) == 2 );
8383       mov2w_op(src, 0);
8384       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
8385       mov2w_op(src, 1);
8386       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
8387       emitpcode(POC_MOVLW, popGetLit (GPTRTAG_CODE));   /* GPOINTER tag for __code space */
8388       call_libraryfunc ("__gptrget1");
8389       break;
8390
8391     case GPOINTER:
8392       assert( AOP_SIZE(src) == 3 );
8393       mov2w_op(src, 0);
8394       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
8395       mov2w_op(src, 1);
8396       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
8397       mov2w_op(src, 2);
8398       call_libraryfunc ("__gptrget1");
8399       break;
8400
8401     default:
8402       assert( !"unhandled pointer type" );
8403       break;
8404     }
8405 }
8406
8407 /*-----------------------------------------------------------------*/
8408 /* emitPtrByteSet - emits code to set a byte from src through a    */
8409 /* pointer register INDF (legacy 8051 uses R0, R1, or DPTR).       */
8410 /*-----------------------------------------------------------------*/
8411 static void
8412 emitPtrByteSet (operand *dst, int p_type, bool alreadyAddressed)
8413 {
8414     FENTRY;
8415     switch (p_type)
8416     {
8417     case POINTER:
8418     case FPOINTER:
8419       if (!alreadyAddressed) setup_fsr (dst);
8420       emitpcode(POC_MOVWF, popCopyReg (&pc_fsr));
8421       break;
8422
8423     case CPOINTER:
8424       assert( !"trying to assign to __code pointer" );
8425       break;
8426
8427     case GPOINTER:
8428       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-2));
8429       mov2w_op(dst, 0);
8430       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
8431       mov2w_op(dst, 1);
8432       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
8433       mov2w_op(dst, 2);
8434       call_libraryfunc ("__gptrput1");
8435       break;
8436
8437     default:
8438       assert( !"unhandled pointer type" );
8439       break;
8440     }
8441 }
8442
8443 /*-----------------------------------------------------------------*/
8444 /* genUnpackBits - generates code for unpacking bits               */
8445 /*-----------------------------------------------------------------*/
8446 static void genUnpackBits (operand *result, operand *left, int ptype, iCode *ifx)
8447 {
8448   int rsize;            /* result size */
8449   sym_link *etype;      /* bitfield type information */
8450   int blen;             /* bitfield length */
8451   int bstr;             /* bitfield starting bit within byte */
8452
8453   FENTRY;
8454   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8455   etype = getSpec(operandType(result));
8456   rsize = getSize (operandType (result));
8457   blen = SPEC_BLEN (etype);
8458   bstr = SPEC_BSTR (etype);
8459
8460   /* single bit field case */
8461   if (blen == 1) {
8462     if (ifx) { /* that is for an if statement */
8463       pCodeOp *pcop;
8464       resolvedIfx rIfx;
8465       resolveIfx(&rIfx,ifx);
8466       if (ptype == -1) /* direct */
8467     pcop = newpCodeOpBit(aopGet (AOP(left),0,FALSE,FALSE),bstr,0);
8468       else
8469     pcop = newpCodeOpBit(pc_indf.pcop.name,bstr,0);
8470       emitpcode((rIfx.condition) ? POC_BTFSC : POC_BTFSS,pcop);
8471       emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
8472       ifx->generated=1;
8473     } else {
8474       int i;
8475       assert (!pic14_sameRegs (AOP(result), AOP(left)));
8476       for (i=0; i < AOP_SIZE(result); i++)
8477     emitpcode (POC_CLRF, popGet (AOP(result), i));
8478
8479       switch (ptype)
8480       {
8481       case -1:
8482         emitpcode(POC_BTFSC,newpCodeOpBit(aopGet (AOP(left),0,FALSE,FALSE),bstr,0));
8483     /* adjust result below */
8484         break;
8485
8486       case POINTER:
8487       case FPOINTER:
8488       case GPOINTER:
8489       case CPOINTER:
8490         emitPtrByteGet (left, ptype, FALSE);
8491     emitpcode(POC_ANDLW, popGetLit (1UL << bstr));
8492     emitSKPZ;
8493     /* adjust result below */
8494         break;
8495
8496       default:
8497         assert( !"unhandled pointer type" );
8498       } // switch
8499
8500       /* move sign-/zero extended bit to result */
8501       if (SPEC_USIGN(OP_SYM_ETYPE(left))) {
8502     emitpcode (POC_INCF, popGet (AOP(result), 0));
8503       } else {
8504     emitpcode (POC_DECF, popGet (AOP(result), 0));
8505       }
8506       addSign (result, 1, !SPEC_USIGN(OP_SYM_ETYPE(left)));
8507     }
8508     return;
8509   }
8510   else if (blen <= 8 && ((blen + bstr) <= 8))
8511   {
8512     /* blen > 1 */
8513     int i;
8514
8515     for (i=0; i < AOP_SIZE(result); i++)
8516       emitpcode (POC_CLRF, popGet (AOP(result), i));
8517
8518     switch (ptype)
8519     {
8520     case -1:
8521       mov2w(AOP(left), 0);
8522       break;
8523
8524     case POINTER:
8525     case FPOINTER:
8526     case GPOINTER:
8527     case CPOINTER:
8528       emitPtrByteGet (left, ptype, FALSE);
8529       break;
8530
8531     default:
8532       assert( !"unhandled pointer type" );
8533     } // switch
8534
8535     if (blen < 8)
8536       emitpcode(POC_ANDLW, popGetLit ((((1UL << blen)-1) << bstr) & 0x00ff));
8537     movwf(AOP(result), 0);
8538     AccRsh (popGet(AOP(result), 0), bstr, 1); /* zero extend the bitfield */
8539
8540     if (!SPEC_USIGN(OP_SYM_ETYPE(left)) && (bstr + blen != 8))
8541     {
8542       /* signed bitfield */
8543       assert (bstr + blen > 0);
8544       emitpcode(POC_MOVLW, popGetLit (0x00ff << (bstr + blen)));
8545       emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE), bstr + blen - 1, 0));
8546       emitpcode(POC_IORWF, popGet(AOP(result),0));
8547     }
8548     addSign (result, 1, !SPEC_USIGN(OP_SYM_ETYPE(left)));
8549     return;
8550   }
8551
8552   assert( !"bitfields larger than 8 bits or crossing byte boundaries are not yet supported" );
8553 }
8554
8555 #if 1
8556 /*-----------------------------------------------------------------*/
8557 /* genDataPointerGet - generates code when ptr offset is known     */
8558 /*-----------------------------------------------------------------*/
8559 static void genDataPointerGet (operand *left,
8560     operand *result,
8561     iCode *ic)
8562 {
8563     int size , offset = 0;
8564
8565     FENTRY;
8566     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8567
8568
8569     /* optimization - most of the time, left and result are the same
8570     * address, but different types. for the pic code, we could omit
8571     * the following
8572     */
8573     aopOp(result,ic,TRUE);
8574
8575     if (pic14_sameRegs (AOP(left), AOP(result)))
8576         return;
8577
8578     DEBUGpic14_AopType(__LINE__,left,NULL,result);
8579
8580     //emitpcode(POC_MOVFW, popGet(AOP(left),0));
8581
8582     size = AOP_SIZE(result);
8583     if (size > getSize(OP_SYM_ETYPE(left))) size = getSize(OP_SYM_ETYPE(left));
8584
8585     offset = 0;
8586     while (size--) {
8587         emitpcode(POC_MOVFW, popGet(AOP(left),offset));
8588         emitpcode(POC_MOVWF, popGet(AOP(result),offset));
8589         offset++;
8590     }
8591
8592     freeAsmop(left,NULL,ic,TRUE);
8593     freeAsmop(result,NULL,ic,TRUE);
8594 }
8595 #endif
8596
8597 /*-----------------------------------------------------------------*/
8598 /* genNearPointerGet - pic14_emitcode for near pointer fetch       */
8599 /*-----------------------------------------------------------------*/
8600 static void genNearPointerGet (operand *left,
8601                                operand *result,
8602                                iCode *ic)
8603 {
8604     asmop *aop = NULL;
8605     sym_link *ltype = operandType(left);
8606     sym_link *rtype = operandType(result);
8607     sym_link *retype= getSpec(rtype);      /* bitfield type information */
8608     int direct = 0;
8609
8610     FENTRY;
8611     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8612
8613
8614     aopOp(left,ic,FALSE);
8615
8616     /* if left is rematerialisable and
8617     result is not bit variable type and
8618     the left is pointer to data space i.e
8619     lower 128 bytes of space */
8620     if (AOP_TYPE(left) == AOP_PCODE &&  //AOP_TYPE(left) == AOP_IMMD &&
8621         !IS_BITVAR(retype)         &&
8622         PIC_IS_DATA_PTR(ltype)) {
8623         genDataPointerGet (left,result,ic);
8624         return ;
8625     }
8626
8627     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8628     aopOp (result,ic,FALSE);
8629
8630     /* Check if can access directly instead of via a pointer */
8631     if ((PCOP(AOP(left))->type == PO_LITERAL || PCOP(AOP(left))->type == PO_IMMEDIATE)
8632         && AOP_SIZE(result) == 1)
8633     {
8634         direct = 1;
8635     }
8636
8637     if (IS_BITFIELD(getSpec(operandType(result))))
8638     {
8639         genUnpackBits (result,left,direct?-1:POINTER,ifxForOp(IC_RESULT(ic),ic));
8640         goto release;
8641     }
8642
8643     /* If the pointer value is not in a the FSR then need to put it in */
8644     /* Must set/reset IRP bit for use with FSR. */
8645     if (!direct)
8646       setup_fsr (left);
8647
8648 //  sym_link *etype;
8649     /* if bitfield then unpack the bits */
8650     {
8651         /* we have can just get the values */
8652         int size = AOP_SIZE(result);
8653         int offset = 0 ;
8654
8655         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8656
8657         while(size--) {
8658             if (direct)
8659                 emitpcode(POC_MOVWF,popGet(AOP(left),0));
8660             else
8661                 emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
8662             if (AOP_TYPE(result) == AOP_LIT) {
8663                 emitpcode(POC_MOVLW,popGet(AOP(result),offset));
8664             } else {
8665                 emitpcode(POC_MOVWF,popGet(AOP(result),offset));
8666             }
8667             if (size && !direct)
8668                 emitpcode(POC_INCF,popCopyReg(&pc_fsr));
8669             offset++;
8670         }
8671     }
8672
8673     /* now some housekeeping stuff */
8674     if (aop) {
8675         /* we had to allocate for this iCode */
8676         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8677         freeAsmop(NULL,aop,ic,TRUE);
8678     } else {
8679         /* we did not allocate which means left
8680         already in a pointer register, then
8681         if size > 0 && this could be used again
8682         we have to point it back to where it
8683         belongs */
8684         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8685         if (AOP_SIZE(result) > 1 &&
8686             !OP_SYMBOL(left)->remat &&
8687             ( OP_SYMBOL(left)->liveTo > ic->seq ||
8688             ic->depth )) {
8689             int size = AOP_SIZE(result) - 1;
8690             while (size--)
8691                 emitpcode(POC_DECF, popCopyReg(&pc_fsr));
8692         }
8693     }
8694
8695 release:
8696     /* done */
8697     freeAsmop(left,NULL,ic,TRUE);
8698     freeAsmop(result,NULL,ic,TRUE);
8699
8700 }
8701
8702 #if 0
8703 /*-----------------------------------------------------------------*/
8704 /* genPagedPointerGet - pic14_emitcode for paged pointer fetch           */
8705 /*-----------------------------------------------------------------*/
8706 static void genPagedPointerGet (operand *left,
8707                                 operand *result,
8708                                 iCode *ic)
8709 {
8710     asmop *aop = NULL;
8711     regs *preg = NULL ;
8712     char *rname ;
8713     sym_link *rtype, *retype;
8714
8715     FENTRY;
8716     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8717
8718     rtype = operandType(result);
8719     retype= getSpec(rtype);
8720
8721     aopOp(left,ic,FALSE);
8722
8723     /* if the value is already in a pointer register
8724     then don't need anything more */
8725     if (!AOP_INPREG(AOP(left))) {
8726         /* otherwise get a free pointer register */
8727         aop = newAsmop(0);
8728         preg = getFreePtr(ic,&aop,FALSE);
8729         pic14_emitcode("mov","%s,%s",
8730             preg->name,
8731             aopGet(AOP(left),0,FALSE,TRUE));
8732         rname = preg->name ;
8733     } else
8734         rname = aopGet(AOP(left),0,FALSE,FALSE);
8735
8736     freeAsmop(left,NULL,ic,TRUE);
8737     aopOp (result,ic,FALSE);
8738
8739     /* if bitfield then unpack the bits */
8740     if (IS_BITFIELD(retype))
8741         genUnpackBits (result,left,rname,PPOINTER,0);
8742     else {
8743         /* we have can just get the values */
8744         int size = AOP_SIZE(result);
8745         int offset = 0 ;
8746
8747         while (size--) {
8748
8749             pic14_emitcode("movx","a,@%s",rname);
8750             aopPut(AOP(result),"a",offset);
8751
8752             offset++ ;
8753
8754             if (size)
8755                 pic14_emitcode("inc","%s",rname);
8756         }
8757     }
8758
8759     /* now some housekeeping stuff */
8760     if (aop) {
8761         /* we had to allocate for this iCode */
8762         freeAsmop(NULL,aop,ic,TRUE);
8763     } else {
8764     /* we did not allocate which means left
8765     already in a pointer register, then
8766     if size > 0 && this could be used again
8767     we have to point it back to where it
8768         belongs */
8769         if (AOP_SIZE(result) > 1 &&
8770             !OP_SYMBOL(left)->remat &&
8771             ( OP_SYMBOL(left)->liveTo > ic->seq ||
8772             ic->depth )) {
8773             int size = AOP_SIZE(result) - 1;
8774             while (size--)
8775                 pic14_emitcode("dec","%s",rname);
8776         }
8777     }
8778
8779     /* done */
8780     freeAsmop(result,NULL,ic,TRUE);
8781
8782
8783 }
8784
8785 /*-----------------------------------------------------------------*/
8786 /* genFarPointerGet - gget value from far space                    */
8787 /*-----------------------------------------------------------------*/
8788 static void genFarPointerGet (operand *left,
8789                               operand *result, iCode *ic)
8790 {
8791     int size, offset ;
8792     sym_link *retype = getSpec(operandType(result));
8793
8794     FENTRY;
8795     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8796
8797     aopOp(left,ic,FALSE);
8798
8799     /* if the operand is already in dptr
8800     then we do nothing else we move the value to dptr */
8801     if (AOP_TYPE(left) != AOP_STR) {
8802         /* if this is remateriazable */
8803         if (AOP_TYPE(left) == AOP_IMMD)
8804             pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
8805         else { /* we need to get it byte by byte */
8806             pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
8807             pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
8808             if (options.model == MODEL_FLAT24)
8809             {
8810                 pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
8811             }
8812         }
8813     }
8814     /* so dptr know contains the address */
8815     freeAsmop(left,NULL,ic,TRUE);
8816     aopOp(result,ic,FALSE);
8817
8818     /* if bit then unpack */
8819     if (IS_BITFIELD(retype))
8820         genUnpackBits(result,left,"dptr",FPOINTER,0);
8821     else {
8822         size = AOP_SIZE(result);
8823         offset = 0 ;
8824
8825         while (size--) {
8826             pic14_emitcode("movx","a,@dptr");
8827             aopPut(AOP(result),"a",offset++);
8828             if (size)
8829                 pic14_emitcode("inc","dptr");
8830         }
8831     }
8832
8833     freeAsmop(result,NULL,ic,TRUE);
8834 }
8835 #endif
8836
8837 #if 0
8838 /*-----------------------------------------------------------------*/
8839 /* genCodePointerGet - get value from code space                  */
8840 /*-----------------------------------------------------------------*/
8841 static void genCodePointerGet (operand *left,
8842                                operand *result, iCode *ic)
8843 {
8844     int size, offset ;
8845     sym_link *retype = getSpec(operandType(result));
8846
8847     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8848
8849     aopOp(left,ic,FALSE);
8850
8851     /* if the operand is already in dptr
8852     then we do nothing else we move the value to dptr */
8853     if (AOP_TYPE(left) != AOP_STR) {
8854         /* if this is remateriazable */
8855         if (AOP_TYPE(left) == AOP_IMMD)
8856             pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
8857         else { /* we need to get it byte by byte */
8858             pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
8859             pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
8860             if (options.model == MODEL_FLAT24)
8861             {
8862                 pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
8863             }
8864         }
8865     }
8866     /* so dptr know contains the address */
8867     freeAsmop(left,NULL,ic,TRUE);
8868     aopOp(result,ic,FALSE);
8869
8870     /* if bit then unpack */
8871     if (IS_BITFIELD(retype))
8872         genUnpackBits(result,left,"dptr",CPOINTER,0);
8873     else {
8874         size = AOP_SIZE(result);
8875         offset = 0 ;
8876
8877         while (size--) {
8878             pic14_emitcode("clr","a");
8879             pic14_emitcode("movc","a,@a+dptr");
8880             aopPut(AOP(result),"a",offset++);
8881             if (size)
8882                 pic14_emitcode("inc","dptr");
8883         }
8884     }
8885
8886     freeAsmop(result,NULL,ic,TRUE);
8887 }
8888 #endif
8889 /*-----------------------------------------------------------------*/
8890 /* genGenPointerGet - gget value from generic pointer space        */
8891 /*-----------------------------------------------------------------*/
8892 static void genGenPointerGet (operand *left,
8893                               operand *result, iCode *ic)
8894 {
8895     FENTRY;
8896     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8897     aopOp(left,ic,FALSE);
8898     aopOp(result,ic,FALSE);
8899
8900
8901     DEBUGpic14_AopType(__LINE__,left,NULL,result);
8902
8903     if (IS_BITFIELD(getSpec(operandType(result))))
8904     {
8905       genUnpackBits (result, left, GPOINTER, ifxForOp (IC_RESULT(ic), ic));
8906       return;
8907     }
8908
8909     {
8910       /* emit call to __gptrget */
8911       char *func[] = {NULL, "__gptrget1", "__gptrget2", "__gptrget3", "__gptrget4"};
8912       int size = AOP_SIZE(result);
8913       int idx = 0;
8914
8915       assert (size > 0 && size <= 4);
8916
8917       /* pass arguments */
8918       assert (AOP_SIZE(left) == 3);
8919       mov2w(AOP(left), 0);
8920       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
8921       mov2w(AOP(left), 1);
8922       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
8923       mov2w(AOP(left), 2);
8924       call_libraryfunc (func[size]);
8925
8926       /* save result */
8927       movwf (AOP(result), --size);
8928       while (size--) {
8929         emitpcode (POC_MOVFW,popRegFromIdx (Gstack_base_addr - idx++));
8930         movwf (AOP(result), size);
8931       } // while
8932     }
8933
8934     freeAsmop(left,NULL,ic,TRUE);
8935     freeAsmop(result,NULL,ic,TRUE);
8936
8937 }
8938
8939 /*-----------------------------------------------------------------*/
8940 /* genConstPointerGet - get value from const generic pointer space */
8941 /*-----------------------------------------------------------------*/
8942 static void genConstPointerGet (operand *left,
8943                                 operand *result, iCode *ic)
8944 {
8945     //sym_link *retype = getSpec(operandType(result));
8946     #if 0
8947     symbol *albl, *blbl;//, *clbl;
8948     pCodeOp *pcop;
8949     #endif
8950     PIC_OPCODE poc;
8951     int i, size, lit;
8952
8953     FENTRY;
8954     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
8955     aopOp(left,ic,FALSE);
8956     aopOp(result,ic,FALSE);
8957
8958     size = AOP_SIZE(result);
8959
8960     DEBUGpic14_AopType(__LINE__,left,NULL,result);
8961
8962     DEBUGpic14_emitcode ("; "," %d getting const pointer",__LINE__);
8963
8964     lit = op_isLitLike (left);
8965     poc = lit ? POC_MOVLW : POC_MOVFW;
8966
8967     if (IS_BITFIELD(getSpec(operandType(result))))
8968     {
8969         genUnpackBits (result, left, lit ? -1 : CPOINTER, ifxForOp (IC_RESULT(ic), ic));
8970         goto release;
8971     }
8972
8973     {
8974         char *func[] = { NULL, "__gptrget1", "__gptrget2", "__gptrget3", "__gptrget4" };
8975         int size = min(getSize(OP_SYM_ETYPE(left)), AOP_SIZE(result));
8976         assert (size > 0 && size <= 4);
8977
8978         mov2w_op(left, 0);
8979         emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr-1));
8980         mov2w_op(left, 1);
8981         emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
8982         emitpcode(POC_MOVLW, popGetLit (GPTRTAG_CODE)); /* GPOINTER tag for __code space */
8983         call_libraryfunc (func[size]);
8984
8985         movwf(AOP(result),size-1);
8986         for (i = 1; i < size; i++)
8987         {
8988             emitpcode(POC_MOVFW, popRegFromIdx (Gstack_base_addr+1-i));
8989             movwf(AOP(result),size - 1 - i);
8990         } // for
8991     }
8992
8993 release:
8994     freeAsmop(left,NULL,ic,TRUE);
8995     freeAsmop(result,NULL,ic,TRUE);
8996
8997 }
8998 /*-----------------------------------------------------------------*/
8999 /* genPointerGet - generate code for pointer get                   */
9000 /*-----------------------------------------------------------------*/
9001 static void genPointerGet (iCode *ic)
9002 {
9003     operand *left, *result ;
9004     sym_link *type, *etype;
9005     int p_type = -1;
9006
9007     FENTRY;
9008     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9009
9010     left = IC_LEFT(ic);
9011     result = IC_RESULT(ic) ;
9012
9013     /* depending on the type of pointer we need to
9014     move it to the correct pointer register */
9015     type = operandType(left);
9016     etype = getSpec(type);
9017
9018     if (IS_PTR_CONST(type))
9019         DEBUGpic14_emitcode ("; ***","%d - const pointer",__LINE__);
9020
9021     /* if left is of type of pointer then it is simple */
9022     if (IS_PTR(type) && !IS_FUNC(type->next))
9023         p_type = DCL_TYPE(type);
9024     else {
9025         /* we have to go by the storage class */
9026         p_type = PTR_TYPE(SPEC_OCLS(etype));
9027
9028         DEBUGpic14_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
9029
9030         if (SPEC_OCLS(etype)->codesp ) {
9031             DEBUGpic14_emitcode ("; ***","%d - cpointer",__LINE__);
9032             //p_type = CPOINTER ;
9033         }
9034         else
9035             if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged)
9036                 DEBUGpic14_emitcode ("; ***","%d - fpointer",__LINE__);
9037             /*p_type = FPOINTER ;*/
9038             else
9039                 if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged)
9040                     DEBUGpic14_emitcode ("; ***","%d - ppointer",__LINE__);
9041                 /*        p_type = PPOINTER; */
9042                 else
9043                     if (SPEC_OCLS(etype) == idata )
9044                         DEBUGpic14_emitcode ("; ***","%d - ipointer",__LINE__);
9045                     /*      p_type = IPOINTER; */
9046                     else
9047                         DEBUGpic14_emitcode ("; ***","%d - pointer",__LINE__);
9048                     /*      p_type = POINTER ; */
9049     }
9050
9051     /* now that we have the pointer type we assign
9052     the pointer values */
9053     switch (p_type) {
9054
9055     case POINTER:
9056     case FPOINTER:
9057     //case IPOINTER:
9058         genNearPointerGet (left,result,ic);
9059         break;
9060 /*
9061     case PPOINTER:
9062         genPagedPointerGet(left,result,ic);
9063         break;
9064
9065     case FPOINTER:
9066         genFarPointerGet (left,result,ic);
9067         break;
9068 */
9069     case CPOINTER:
9070         genConstPointerGet (left,result,ic);
9071         break;
9072
9073     case GPOINTER:
9074         genGenPointerGet (left,result,ic);
9075         break;
9076     default:
9077         assert ( !"unhandled pointer type" );
9078         break;
9079     }
9080
9081 }
9082
9083 /*-----------------------------------------------------------------*/
9084 /* genPackBits - generates code for packed bit storage             */
9085 /*-----------------------------------------------------------------*/
9086 static void genPackBits(sym_link *etype,operand *result,operand *right,int p_type)
9087 {
9088   int blen;             /* bitfield length */
9089   int bstr;             /* bitfield starting bit within byte */
9090   int litval;           /* source literal value (if AOP_LIT) */
9091   unsigned char mask;   /* bitmask within current byte */
9092
9093   FENTRY;
9094   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9095
9096   blen = SPEC_BLEN (etype);
9097   bstr = SPEC_BSTR (etype);
9098
9099   /* If the bitfield length is less than a byte and does not cross byte boundaries */
9100   if ((blen <= 8) && ((bstr + blen) <= 8))
9101   {
9102     mask = ((unsigned char) (0xFF << (blen + bstr)) |
9103         (unsigned char) (0xFF >> (8 - bstr)));
9104
9105     if (AOP_TYPE (right) == AOP_LIT)
9106     {
9107       /* Case with a bitfield length <8 and literal source */
9108       int lit = (int) ulFromVal (AOP (right)->aopu.aop_lit);
9109       if (blen == 1) {
9110         pCodeOp *pcop;
9111
9112     switch (p_type)
9113     {
9114     case -1:
9115       if (AOP(result)->type == AOP_PCODE)
9116         pcop = newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE),bstr,0);
9117       else
9118         pcop = popGet(AOP(result),0);
9119       emitpcode(lit?POC_BSF:POC_BCF,pcop);
9120       break;
9121
9122     case POINTER:
9123     case FPOINTER:
9124       setup_fsr (result);
9125       emitpcode(lit?POC_BSF:POC_BCF,newpCodeOpBit(PCOP(&pc_indf)->name,bstr,0));
9126       break;
9127
9128     case CPOINTER:
9129       assert( !"trying to assign to bitfield via pointer to __code space" );
9130       break;
9131
9132     case GPOINTER:
9133       emitPtrByteGet(result, p_type, FALSE);
9134       if (lit) {
9135         emitpcode(POC_IORLW, newpCodeOpLit (1UL << bstr));
9136       } else {
9137         emitpcode(POC_ANDLW, newpCodeOpLit ((~(1UL << bstr)) & 0x0ff));
9138       }
9139       emitPtrByteSet(result, p_type, TRUE);
9140       break;
9141
9142     default:
9143       assert( !"unhandled pointer type" );
9144       break;
9145     } // switch (p_type)
9146       } else {
9147         /* blen > 1 */
9148     litval = lit << bstr;
9149     litval &= (~mask) & 0x00ff;
9150
9151     switch (p_type)
9152     {
9153     case -1:
9154       mov2w (AOP(result), 0);
9155       if ((litval|mask) != 0x00ff)
9156         emitpcode(POC_ANDLW, popGetLit (mask));
9157       if (litval != 0x00)
9158         emitpcode(POC_IORLW, popGetLit (litval));
9159       movwf (AOP(result), 0);
9160       break;
9161
9162     case POINTER:
9163     case FPOINTER:
9164     case GPOINTER:
9165       emitPtrByteGet(result, p_type, FALSE);
9166       if ((litval|mask) != 0x00ff)
9167         emitpcode(POC_ANDLW, popGetLit (mask));
9168       if (litval != 0x00)
9169         emitpcode(POC_IORLW, popGetLit (litval));
9170       emitPtrByteSet(result, p_type, TRUE);
9171       break;
9172
9173     case CPOINTER:
9174       assert( !"trying to assign to bitfield via pointer to __code space" );
9175       break;
9176
9177     default:
9178       assert( !"unhandled pointer type" );
9179       break;
9180     } // switch
9181       } // if (blen > 1)
9182     }
9183     else
9184     {
9185       /* right is no literal */
9186       if (blen==1) {
9187         switch (p_type)
9188     {
9189     case -1:
9190       /* Note more efficient code, of pre clearing bit then only setting it if required,
9191        * can only be done if it is known that the result is not a SFR */
9192       emitpcode(POC_RRFW,popGet(AOP(right),0));
9193       emitSKPC;
9194       emitpcode(POC_BCF,newpCodeOpBit (aopGet(AOP(result), 0, FALSE, FALSE), bstr, 0));
9195       emitSKPNC;
9196       emitpcode(POC_BSF,newpCodeOpBit (aopGet(AOP(result), 0, FALSE, FALSE), bstr, 0));
9197       break;
9198
9199     case POINTER:
9200     case FPOINTER:
9201     case GPOINTER:
9202       emitPtrByteGet (result, p_type, FALSE);
9203       emitpcode(POC_BTFSS, newpCodeOpBit (aopGet(AOP(right), 0, FALSE, FALSE), bstr, 0));
9204       emitpcode(POC_ANDLW, newpCodeOpLit (~(1UL << bstr) & 0x0ff));
9205       emitpcode(POC_BTFSC, newpCodeOpBit (aopGet(AOP(right), 0, FALSE, FALSE), bstr, 0));
9206       emitpcode(POC_IORLW, newpCodeOpLit ((1UL << bstr) & 0x0ff));
9207       emitPtrByteSet (result, p_type, TRUE);
9208       break;
9209
9210     case CPOINTER:
9211       assert( !"trying to assign to bitfield via pointer to __code space" );
9212       break;
9213
9214     default:
9215       assert( !"unhandled pointer type" );
9216       break;
9217     } // switch
9218     return;
9219       } else {
9220     /* Case with a bitfield 1 < length <= 8 and arbitrary source */
9221     pCodeOp *temp = popGetTempReg ();
9222
9223     mov2w (AOP(right), 0);
9224     if (blen < 8) {
9225       emitpcode (POC_ANDLW, popGetLit ((1UL << blen)-1));
9226     }
9227     emitpcode(POC_MOVWF, temp);
9228     if (bstr) {
9229       AccLsh (temp, bstr);
9230     }
9231
9232     switch (p_type)
9233     {
9234     case -1:
9235       mov2w (AOP(result), 0);
9236       emitpcode(POC_ANDLW, popGetLit (mask));
9237       emitpcode(POC_IORFW, temp);
9238       movwf (AOP(result), 0);
9239       break;
9240
9241     case POINTER:
9242     case FPOINTER:
9243     case GPOINTER:
9244       emitPtrByteGet (result, p_type, FALSE);
9245       emitpcode(POC_ANDLW, popGetLit (mask));
9246       emitpcode(POC_IORFW, temp);
9247       emitPtrByteSet (result, p_type, TRUE);
9248       break;
9249
9250     case CPOINTER:
9251       assert( !"trying to assign to bitfield via pointer to __code space" );
9252       break;
9253
9254     default:
9255       assert( !"unhandled pointer type" );
9256       break;
9257     } // switch
9258
9259     popReleaseTempReg (temp);
9260       } // if (blen > 1)
9261     } // if (AOP(right)->type != AOP_LIT)
9262     return;
9263   } // if (blen <= 8 && ((blen + bstr) <= 8))
9264
9265   assert( !"bitfields larger than 8 bits or crossing byte boundaries are not yet supported" );
9266 }
9267
9268 /*-----------------------------------------------------------------*/
9269 /* genDataPointerSet - remat pointer to data space                 */
9270 /*-----------------------------------------------------------------*/
9271 static void genDataPointerSet(operand *right,
9272     operand *result,
9273     iCode *ic)
9274 {
9275     int size, offset = 0 ;
9276     int ressize;
9277
9278     FENTRY;
9279     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9280     aopOp(right,ic,FALSE);
9281     aopOp(result,ic,FALSE);
9282
9283     assert (IS_SYMOP(result));
9284     assert (IS_PTR(OP_SYM_TYPE(result)));
9285
9286     if (AOP_TYPE(right) == AOP_LIT)
9287       size = 4;
9288     else
9289       size = AOP_SIZE(right);
9290     ressize = getSize(OP_SYM_ETYPE(result));
9291     if (size > ressize) size = ressize;
9292     //fprintf (stderr, "%s:%u: size(right): %d, size(result): %d\n", __FUNCTION__,__LINE__, AOP_SIZE(right), ressize);
9293
9294     //assert( !"what's going on here?" );
9295
9296     /*
9297     if ( AOP_TYPE(result) == AOP_PCODE) {
9298     fprintf(stderr,"genDataPointerSet   %s, %d\n",
9299     AOP(result)->aopu.pcop->name,
9300     PCOI(AOP(result)->aopu.pcop)->offset);
9301     }
9302     */
9303
9304     // tsd, was l+1 - the underline `_' prefix was being stripped
9305     while (size--) {
9306         emitpComment ("%s:%u: size=%d/%d, offset=%d, AOP_TYPE(res)=%d", __FILE__,__LINE__, size, ressize, offset, AOP_TYPE(result));
9307
9308         if (AOP_TYPE(right) == AOP_LIT) {
9309             unsigned int lit = pic14aopLiteral(AOP(IC_RIGHT(ic))->aopu.aop_lit, offset);
9310             //fprintf (stderr, "%s:%u: lit %d 0x%x\n", __FUNCTION__,__LINE__, lit, lit);
9311             if(lit&0xff) {
9312                 emitpcode(POC_MOVLW, popGetLit(lit&0xff));
9313                 emitpcode(POC_MOVWF, popGet(AOP(result), offset));
9314             } else {
9315                 emitpcode(POC_CLRF, popGet(AOP(result), offset));
9316             }
9317         } else {
9318             //fprintf (stderr, "%s:%u: no lit\n", __FUNCTION__,__LINE__);
9319             emitpcode(POC_MOVFW, popGet(AOP(right), offset));
9320             emitpcode(POC_MOVWF, popGet(AOP(result), offset));
9321         }
9322
9323         offset++;
9324     }
9325
9326     freeAsmop(right,NULL,ic,TRUE);
9327     freeAsmop(result,NULL,ic,TRUE);
9328 }
9329
9330 /*-----------------------------------------------------------------*/
9331 /* genNearPointerSet - pic14_emitcode for near pointer put         */
9332 /*-----------------------------------------------------------------*/
9333 static void genNearPointerSet (operand *right,
9334                                operand *result,
9335                                iCode *ic)
9336 {
9337     asmop *aop = NULL;
9338     sym_link *ptype = operandType(result);
9339     sym_link *retype = getSpec(operandType(right));
9340     sym_link *letype = getSpec(ptype);
9341     int direct = 0;
9342
9343
9344     FENTRY;
9345     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9346     aopOp(result,ic,FALSE);
9347
9348 #if 1
9349     /* if the result is rematerializable &
9350     in data space & not a bit variable */
9351     //if (AOP_TYPE(result) == AOP_IMMD &&
9352     if (AOP_TYPE(result) == AOP_PCODE &&
9353         PIC_IS_DATA_PTR(ptype) &&
9354         !IS_BITVAR (retype) &&
9355         !IS_BITVAR (letype)) {
9356         genDataPointerSet (right,result,ic);
9357         freeAsmop(result,NULL,ic,TRUE);
9358         return;
9359     }
9360 #endif
9361
9362     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9363     aopOp(right,ic,FALSE);
9364     DEBUGpic14_AopType(__LINE__,NULL,right,result);
9365
9366     /* Check if can access directly instead of via a pointer */
9367     if (PCOP(AOP(result))->type == PO_LITERAL && AOP_SIZE(right) == 1) {
9368         direct = 1;
9369     }
9370
9371     if (IS_BITFIELD (letype))
9372     {
9373       genPackBits (letype, result, right, direct?-1:POINTER);
9374       return;
9375     }
9376
9377     /* If the pointer value is not in a the FSR then need to put it in */
9378     /* Must set/reset IRP bit for use with FSR. */
9379     /* Note only do this once - assuming that never need to cross a bank boundary at address 0x100. */
9380     if (!direct)
9381         setup_fsr (result);
9382
9383     {
9384         /* we have can just get the values */
9385         int size = AOP_SIZE(right);
9386         int offset = 0 ;
9387
9388         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9389         while (size--) {
9390             char *l = aopGet(AOP(right),offset,FALSE,TRUE);
9391             if (*l == '@' ) {
9392                 emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
9393             } else {
9394                 if (AOP_TYPE(right) == AOP_LIT) {
9395                     emitpcode(POC_MOVLW,popGet(AOP(right),offset));
9396                 } else {
9397                     emitpcode(POC_MOVFW,popGet(AOP(right),offset));
9398                 }
9399                 if (direct)
9400                     emitpcode(POC_MOVWF,popGet(AOP(result),0));
9401                 else
9402                     emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
9403             }
9404             if (size && !direct)
9405                 emitpcode(POC_INCF,popCopyReg(&pc_fsr));
9406             offset++;
9407         }
9408     }
9409
9410     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9411     /* now some housekeeping stuff */
9412     if (aop) {
9413         /* we had to allocate for this iCode */
9414         freeAsmop(NULL,aop,ic,TRUE);
9415     } else {
9416         /* we did not allocate which means left
9417         already in a pointer register, then
9418         if size > 0 && this could be used again
9419         we have to point it back to where it
9420         belongs */
9421         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9422         if (AOP_SIZE(right) > 1 &&
9423             !OP_SYMBOL(result)->remat &&
9424             ( OP_SYMBOL(result)->liveTo > ic->seq ||
9425             ic->depth )) {
9426             int size = AOP_SIZE(right) - 1;
9427             while (size--)
9428                 emitpcode(POC_DECF, popCopyReg(&pc_fsr));
9429         }
9430     }
9431
9432     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9433     /* done */
9434
9435     freeAsmop(right,NULL,ic,TRUE);
9436     freeAsmop(result,NULL,ic,TRUE);
9437 }
9438
9439 #if 0
9440 /*-----------------------------------------------------------------*/
9441 /* genPagedPointerSet - pic14_emitcode for Paged pointer put             */
9442 /*-----------------------------------------------------------------*/
9443 static void genPagedPointerSet (operand *right,
9444                                 operand *result,
9445                                 iCode *ic)
9446 {
9447     asmop *aop = NULL;
9448     regs *preg = NULL ;
9449     char *rname , *l;
9450     sym_link *retype;
9451
9452     FENTRY;
9453     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9454
9455     retype= getSpec(operandType(right));
9456
9457     aopOp(result,ic,FALSE);
9458
9459     /* if the value is already in a pointer register
9460     then don't need anything more */
9461     if (!AOP_INPREG(AOP(result))) {
9462         /* otherwise get a free pointer register */
9463         aop = newAsmop(0);
9464         preg = getFreePtr(ic,&aop,FALSE);
9465         pic14_emitcode("mov","%s,%s",
9466             preg->name,
9467             aopGet(AOP(result),0,FALSE,TRUE));
9468         rname = preg->name ;
9469     } else
9470         rname = aopGet(AOP(result),0,FALSE,FALSE);
9471
9472     freeAsmop(result,NULL,ic,TRUE);
9473     aopOp (right,ic,FALSE);
9474
9475     /* if bitfield then unpack the bits */
9476     if (IS_BITFIELD(retype))
9477         genPackBits (retype,result,right,rname,PPOINTER);
9478     else {
9479         /* we have can just get the values */
9480         int size = AOP_SIZE(right);
9481         int offset = 0 ;
9482
9483         while (size--) {
9484             l = aopGet(AOP(right),offset,FALSE,TRUE);
9485
9486             MOVA(l);
9487             pic14_emitcode("movx","@%s,a",rname);
9488
9489             if (size)
9490                 pic14_emitcode("inc","%s",rname);
9491
9492             offset++;
9493         }
9494     }
9495
9496     /* now some housekeeping stuff */
9497     if (aop) {
9498         /* we had to allocate for this iCode */
9499         freeAsmop(NULL,aop,ic,TRUE);
9500     } else {
9501     /* we did not allocate which means left
9502     already in a pointer register, then
9503     if size > 0 && this could be used again
9504     we have to point it back to where it
9505         belongs */
9506         if (AOP_SIZE(right) > 1 &&
9507             !OP_SYMBOL(result)->remat &&
9508             ( OP_SYMBOL(result)->liveTo > ic->seq ||
9509             ic->depth )) {
9510             int size = AOP_SIZE(right) - 1;
9511             while (size--)
9512                 pic14_emitcode("dec","%s",rname);
9513         }
9514     }
9515
9516     /* done */
9517     freeAsmop(right,NULL,ic,TRUE);
9518
9519
9520 }
9521
9522 /*-----------------------------------------------------------------*/
9523 /* genFarPointerSet - set value from far space                     */
9524 /*-----------------------------------------------------------------*/
9525 static void genFarPointerSet (operand *right,
9526                               operand *result, iCode *ic)
9527 {
9528     int size, offset ;
9529     sym_link *retype = getSpec(operandType(right));
9530
9531     FENTRY;
9532     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9533     aopOp(result,ic,FALSE);
9534
9535     /* if the operand is already in dptr
9536     then we do nothing else we move the value to dptr */
9537     if (AOP_TYPE(result) != AOP_STR) {
9538         /* if this is remateriazable */
9539         if (AOP_TYPE(result) == AOP_IMMD)
9540             pic14_emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE));
9541         else { /* we need to get it byte by byte */
9542             pic14_emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE));
9543             pic14_emitcode("mov","dph,%s",aopGet(AOP(result),1,FALSE,FALSE));
9544             if (options.model == MODEL_FLAT24)
9545             {
9546                 pic14_emitcode("mov", "dpx,%s",aopGet(AOP(result),2,FALSE,FALSE));
9547             }
9548         }
9549     }
9550     /* so dptr know contains the address */
9551     freeAsmop(result,NULL,ic,TRUE);
9552     aopOp(right,ic,FALSE);
9553
9554     /* if bit then unpack */
9555     if (IS_BITFIELD(retype))
9556         genPackBits(retype,result,right,"dptr",FPOINTER);
9557     else {
9558         size = AOP_SIZE(right);
9559         offset = 0 ;
9560
9561         while (size--) {
9562             char *l = aopGet(AOP(right),offset++,FALSE,FALSE);
9563             MOVA(l);
9564             pic14_emitcode("movx","@dptr,a");
9565             if (size)
9566                 pic14_emitcode("inc","dptr");
9567         }
9568     }
9569
9570     freeAsmop(right,NULL,ic,TRUE);
9571 }
9572 #endif
9573
9574 /*-----------------------------------------------------------------*/
9575 /* genGenPointerSet - set value from generic pointer space         */
9576 /*-----------------------------------------------------------------*/
9577 static void genGenPointerSet (operand *right, operand *result, iCode *ic)
9578 {
9579     sym_link *retype = getSpec(operandType(result));
9580
9581     FENTRY;
9582     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9583     aopOp(right,ic,FALSE);
9584     aopOp(result,ic,FALSE);
9585
9586
9587     DEBUGpic14_AopType(__LINE__,right,NULL,result);
9588
9589     if (IS_BITFIELD(retype))
9590     {
9591       genPackBits (retype, result, right, GPOINTER);
9592       return;
9593     }
9594
9595     {
9596       /* emit call to __gptrput */
9597       char *func[] = {NULL, "__gptrput1", "__gptrput2", "__gptrput3", "__gptrput4"};
9598       int size = AOP_SIZE(right);
9599       int idx = 0;
9600
9601       /* The following assertion fails for
9602        *   struct foo { char a; char b; } bar;
9603        *   void demo(struct foo *dst, char c) { dst->b = c; }
9604        * as size will be 1 (sizeof(c)), whereas dst->b will be accessed
9605        * using (((char *)dst)+1), whose OP_SYM_ETYPE still is struct foo
9606        * of size 2.
9607        * The frontend seems to guarantee that IC_LEFT has the correct size,
9608        * it works fine both for larger and smaller types of `char c'.
9609        * */
9610       //assert (size == getSize(OP_SYM_ETYPE(result)));
9611       assert (size > 0 && size <= 4);
9612
9613       /* pass arguments */
9614       /* - value (MSB in Gstack_base_addr-2, growing downwards) */
9615       {
9616         int off = size;
9617         idx = 2;
9618         while (off--)
9619         {
9620           mov2w_op (right, off);
9621           emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - idx++));
9622         }
9623         idx = 0;
9624       }
9625       /* - address */
9626       assert (AOP_SIZE(result) == 3);
9627       mov2w(AOP(result), 0);
9628       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
9629       mov2w(AOP(result), 1);
9630       emitpcode(POC_MOVWF, popRegFromIdx (Gstack_base_addr));
9631       mov2w(AOP(result), 2);
9632       call_libraryfunc (func[size]);
9633     }
9634
9635     freeAsmop(right,NULL,ic,TRUE);
9636     freeAsmop(result,NULL,ic,TRUE);
9637 }
9638
9639 /*-----------------------------------------------------------------*/
9640 /* genPointerSet - stores the value into a pointer location        */
9641 /*-----------------------------------------------------------------*/
9642 static void genPointerSet (iCode *ic)
9643 {
9644     operand *right, *result ;
9645     sym_link *type, *etype;
9646     int p_type;
9647
9648     FENTRY;
9649     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9650
9651     right = IC_RIGHT(ic);
9652     result = IC_RESULT(ic) ;
9653
9654     /* depending on the type of pointer we need to
9655     move it to the correct pointer register */
9656     type = operandType(result);
9657     etype = getSpec(type);
9658     /* if left is of type of pointer then it is simple */
9659     if (IS_PTR(type) && !IS_FUNC(type->next)) {
9660         p_type = DCL_TYPE(type);
9661     }
9662     else {
9663         /* we have to go by the storage class */
9664         p_type = PTR_TYPE(SPEC_OCLS(etype));
9665
9666         /*  if (SPEC_OCLS(etype)->codesp ) { */
9667         /*      p_type = CPOINTER ;  */
9668         /*  } */
9669         /*  else */
9670         /*      if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
9671         /*    p_type = FPOINTER ; */
9672         /*      else */
9673         /*    if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
9674         /*        p_type = PPOINTER ; */
9675         /*    else */
9676         /*        if (SPEC_OCLS(etype) == idata ) */
9677         /*      p_type = IPOINTER ; */
9678         /*        else */
9679         /*      p_type = POINTER ; */
9680     }
9681
9682     /* now that we have the pointer type we assign
9683     the pointer values */
9684     switch (p_type) {
9685
9686     case POINTER:
9687     case FPOINTER:
9688     //case IPOINTER:
9689         genNearPointerSet (right,result,ic);
9690         break;
9691 /*
9692     case PPOINTER:
9693         genPagedPointerSet (right,result,ic);
9694         break;
9695
9696     case FPOINTER:
9697         genFarPointerSet (right,result,ic);
9698         break;
9699 */
9700     case GPOINTER:
9701         genGenPointerSet (right,result,ic);
9702         break;
9703
9704     default:
9705         werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
9706             "genPointerSet: illegal pointer type");
9707     }
9708 }
9709
9710 /*-----------------------------------------------------------------*/
9711 /* genIfx - generate code for Ifx statement                        */
9712 /*-----------------------------------------------------------------*/
9713 static void genIfx (iCode *ic, iCode *popIc)
9714 {
9715     operand *cond = IC_COND(ic);
9716     int isbit =0;
9717
9718     FENTRY;
9719     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9720
9721     aopOp(cond,ic,FALSE);
9722
9723     /* get the value into acc */
9724     if (AOP_TYPE(cond) != AOP_CRY)
9725         pic14_toBoolean(cond);
9726     else
9727         isbit = 1;
9728
9729     /* if there was something to be popped then do it */
9730     if (popIc)
9731         genIpop(popIc);
9732
9733     if (isbit)
9734     {
9735         /* This assumes that CARRY is set iff cond is true */
9736         if (IC_TRUE(ic))
9737         {
9738             assert (!IC_FALSE(ic));
9739             emitpcode(POC_BTFSC, popGet(AOP(cond), 0));
9740             //emitSKPNC;
9741             emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key));
9742         } else {
9743             assert (IC_FALSE(ic));
9744             emitpcode(POC_BTFSS, popGet(AOP(cond), 0));
9745             //emitSKPC;
9746             emitpcode(POC_GOTO, popGetLabel(IC_FALSE(ic)->key));
9747         }
9748         if (0)
9749         {
9750             static int hasWarned = 0;
9751             if (!hasWarned)
9752             {
9753                 fprintf (stderr, "WARNING: using untested code for %s:%u -- please check the .asm output and report bugs.\n", ic->filename, ic->lineno);
9754                 hasWarned = 1;
9755             }
9756         }
9757     }
9758     else
9759     {
9760         /* now Z is set iff !cond */
9761         if (IC_TRUE(ic))
9762         {
9763             assert (!IC_FALSE(ic));
9764             emitSKPZ;
9765             emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key));
9766         } else {
9767             emitSKPNZ;
9768             emitpcode(POC_GOTO, popGetLabel(IC_FALSE(ic)->key));
9769         }
9770     }
9771
9772     ic->generated = 1;
9773
9774     /* the result is now in the accumulator */
9775     freeAsmop(cond,NULL,ic,TRUE);
9776 }
9777
9778 /*-----------------------------------------------------------------*/
9779 /* genAddrOf - generates code for address of                       */
9780 /*-----------------------------------------------------------------*/
9781 static void genAddrOf (iCode *ic)
9782 {
9783     operand *right, *result, *left;
9784     int size, offset ;
9785
9786     FENTRY;
9787     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9788
9789
9790     //aopOp(IC_RESULT(ic),ic,FALSE);
9791
9792     aopOp((left=IC_LEFT(ic)),ic,FALSE);
9793     aopOp((right=IC_RIGHT(ic)),ic,FALSE);
9794     aopOp((result=IC_RESULT(ic)),ic,TRUE);
9795
9796     DEBUGpic14_AopType(__LINE__,left,right,result);
9797     assert (IS_SYMOP (left));
9798
9799     /* sanity check: generic pointers to code space are not yet supported,
9800      * pionters to codespace must not be assigned addresses of __data values. */
9801  #if 0
9802     fprintf (stderr, "result: %s, left: %s\n", OP_SYMBOL(result)->name, OP_SYMBOL(left)->name);
9803     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)));
9804     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)));
9805     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)));
9806     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)));
9807 #endif
9808
9809     if (IS_CODEPTR(OP_SYM_TYPE(result)) && !IN_CODESPACE(SPEC_OCLS(getSpec (OP_SYM_TYPE(left))))) {
9810       fprintf (stderr, "trying to assign __code pointer (%s) an address in __data space (&%s) -- expect trouble\n",
9811         IS_SYMOP(result) ? OP_SYMBOL(result)->name : "unknown",
9812         OP_SYMBOL(left)->name);
9813     } else if (!IS_CODEPTR (OP_SYM_TYPE(result)) && IN_CODESPACE(SPEC_OCLS(getSpec(OP_SYM_TYPE(left))))) {
9814       fprintf (stderr, "trying to assign __data pointer (%s) an address in __code space (&%s) -- expect trouble\n",
9815         IS_SYMOP(result) ? OP_SYMBOL(result)->name : "unknown",
9816         OP_SYMBOL(left)->name);
9817     }
9818
9819     size = AOP_SIZE(IC_RESULT(ic));
9820     if (IS_GENPTR(OP_SYM_TYPE(result))) {
9821         /* strip tag */
9822         if (size > GPTRSIZE-1) size = GPTRSIZE-1;
9823     }
9824     offset = 0;
9825
9826     while (size--) {
9827         /* fixing bug #863624, reported from (errolv) */
9828         emitpcode(POC_MOVLW, popGetImmd(OP_SYMBOL(left)->rname, offset, 0, IS_FUNC(OP_SYM_TYPE(left))));
9829         emitpcode(POC_MOVWF, popGet(AOP(result), offset));
9830
9831 #if 0
9832         emitpcode(POC_MOVLW, popGet(AOP(left),offset));
9833         emitpcode(POC_MOVWF, popGet(AOP(result),offset));
9834 #endif
9835         offset++;
9836     }
9837
9838     if (IS_GENPTR(OP_SYM_TYPE(result)))
9839     {
9840         /* provide correct tag */
9841         int isCode = IN_CODESPACE(SPEC_OCLS(getSpec(OP_SYM_TYPE(left))));
9842         emitpcode (POC_MOVLW, popGetLit (isCode ? GPTRTAG_CODE : GPTRTAG_DATA));
9843         movwf (AOP(result), 2);
9844     }
9845
9846     freeAsmop(left,NULL,ic,FALSE);
9847     freeAsmop(result,NULL,ic,TRUE);
9848
9849 }
9850
9851 #if 0
9852 /*-----------------------------------------------------------------*/
9853 /* genFarFarAssign - assignment when both are in far space         */
9854 /*-----------------------------------------------------------------*/
9855 static void genFarFarAssign (operand *result, operand *right, iCode *ic)
9856 {
9857     int size = AOP_SIZE(right);
9858     int offset = 0;
9859     char *l ;
9860     /* first push the right side on to the stack */
9861     while (size--) {
9862         l = aopGet(AOP(right),offset++,FALSE,FALSE);
9863         MOVA(l);
9864         pic14_emitcode ("push","acc");
9865     }
9866
9867     freeAsmop(right,NULL,ic,FALSE);
9868     /* now assign DPTR to result */
9869     aopOp(result,ic,FALSE);
9870     size = AOP_SIZE(result);
9871     while (size--) {
9872         pic14_emitcode ("pop","acc");
9873         aopPut(AOP(result),"a",--offset);
9874     }
9875     freeAsmop(result,NULL,ic,FALSE);
9876
9877 }
9878 #endif
9879
9880 /*-----------------------------------------------------------------*/
9881 /* genAssign - generate code for assignment                        */
9882 /*-----------------------------------------------------------------*/
9883 static void genAssign (iCode *ic)
9884 {
9885     operand *result, *right;
9886     int size, offset,know_W;
9887     unsigned long lit = 0L;
9888
9889     result = IC_RESULT(ic);
9890     right  = IC_RIGHT(ic) ;
9891
9892     FENTRY;
9893     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9894
9895     /* if they are the same */
9896     if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
9897         return ;
9898
9899     aopOp(right,ic,FALSE);
9900     aopOp(result,ic,TRUE);
9901
9902     DEBUGpic14_AopType(__LINE__,NULL,right,result);
9903
9904     /* if they are the same registers */
9905     if (pic14_sameRegs(AOP(right),AOP(result)))
9906         goto release;
9907
9908     /* special case: assign from __code */
9909     if (!IS_ITEMP(right)                /* --> iTemps never reside in __code */
9910         && IS_SYMOP (right)         /* --> must be an immediate (otherwise we would be in genConstPointerGet) */
9911         && !IS_FUNC(OP_SYM_TYPE(right))     /* --> we would want its address instead of the first instruction */
9912         && !IS_CODEPTR(OP_SYM_TYPE(right))  /* --> get symbols address instread */
9913         && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE(right)))))
9914     {
9915       emitpComment ("genAssign from CODESPACE");
9916       genConstPointerGet (right, result, ic);
9917       goto release;
9918     }
9919
9920     /* just for symmetry reasons... */
9921     if (!IS_ITEMP(result)
9922         && IS_SYMOP (result)
9923         && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE(result)))))
9924     {
9925       assert ( !"cannot write to CODESPACE" );
9926     }
9927
9928     /* if the result is a bit */
9929     if (AOP_TYPE(result) == AOP_CRY) {
9930
9931     /* if the right size is a literal then
9932         we know what the value is */
9933         if (AOP_TYPE(right) == AOP_LIT) {
9934
9935             emitpcode(  ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
9936                 popGet(AOP(result),0));
9937
9938             if (((int) operandLitValue(right)))
9939                 pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
9940                 AOP(result)->aopu.aop_dir,
9941                 AOP(result)->aopu.aop_dir);
9942             else
9943                 pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
9944                 AOP(result)->aopu.aop_dir,
9945                 AOP(result)->aopu.aop_dir);
9946             goto release;
9947         }
9948
9949         /* the right is also a bit variable */
9950         if (AOP_TYPE(right) == AOP_CRY) {
9951             emitpcode(POC_BCF,    popGet(AOP(result),0));
9952             emitpcode(POC_BTFSC,  popGet(AOP(right),0));
9953             emitpcode(POC_BSF,    popGet(AOP(result),0));
9954
9955             pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
9956                 AOP(result)->aopu.aop_dir,
9957                 AOP(result)->aopu.aop_dir);
9958             pic14_emitcode("btfsc","(%s >> 3),(%s & 7)",
9959                 AOP(right)->aopu.aop_dir,
9960                 AOP(right)->aopu.aop_dir);
9961             pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
9962                 AOP(result)->aopu.aop_dir,
9963                 AOP(result)->aopu.aop_dir);
9964             goto release ;
9965         }
9966
9967         /* we need to or */
9968         emitpcode(POC_BCF,    popGet(AOP(result),0));
9969         pic14_toBoolean(right);
9970         emitSKPZ;
9971         emitpcode(POC_BSF,    popGet(AOP(result),0));
9972         //aopPut(AOP(result),"a",0);
9973         goto release ;
9974     }
9975
9976     /* bit variables done */
9977     /* general case */
9978     size = AOP_SIZE(result);
9979     offset = 0 ;
9980     if( AOP_TYPE(right) == AOP_DIR  && (AOP_TYPE(result) == AOP_REG) && size==1)  {
9981         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9982         if(aopIdx(AOP(result),0) == 4) {
9983             DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9984             emitpcode(POC_MOVFW, popGet(AOP(right),offset));
9985             emitpcode(POC_MOVWF, popGet(AOP(result),offset));
9986             goto release;
9987         } else
9988             DEBUGpic14_emitcode ("; WARNING","%s  %d ignoring register storage",__FUNCTION__,__LINE__);
9989     }
9990
9991     know_W=-1;
9992     while (size--) {
9993
9994         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
9995         if(AOP_TYPE(right) == AOP_LIT) {
9996             lit = (unsigned long)pic14aopLiteral(AOP(right)->aopu.aop_lit, offset) & 0x0ff;
9997             if(lit&0xff) {
9998                 if(know_W != (int)(lit&0xff))
9999                     emitpcode(POC_MOVLW,popGetLit(lit&0xff));
10000                 know_W = lit&0xff;
10001                 emitpcode(POC_MOVWF, popGet(AOP(result),offset));
10002             } else
10003                 emitpcode(POC_CLRF, popGet(AOP(result),offset));
10004
10005         } else if (AOP_TYPE(right) == AOP_CRY) {
10006             emitpcode(POC_CLRF, popGet(AOP(result),offset));
10007             if(offset == 0) {
10008                 emitpcode(POC_BTFSS, popGet(AOP(right),0));
10009                 emitpcode(POC_INCF, popGet(AOP(result),0));
10010             }
10011         } else {
10012             mov2w_op (right, offset);
10013             emitpcode(POC_MOVWF, popGet(AOP(result),offset));
10014         }
10015
10016         offset++;
10017     }
10018
10019
10020 release:
10021     freeAsmop (right,NULL,ic,FALSE);
10022     freeAsmop (result,NULL,ic,TRUE);
10023 }
10024
10025 /*-----------------------------------------------------------------*/
10026 /* genJumpTab - genrates code for jump table                       */
10027 /*-----------------------------------------------------------------*/
10028 static void genJumpTab (iCode *ic)
10029 {
10030     symbol *jtab;
10031     char *l;
10032
10033     FENTRY;
10034     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
10035
10036     aopOp(IC_JTCOND(ic),ic,FALSE);
10037     /* get the condition into accumulator */
10038     l = aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE);
10039     MOVA(l);
10040     /* multiply by three */
10041     pic14_emitcode("add","a,acc");
10042     pic14_emitcode("add","a,%s",aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE));
10043
10044     jtab = newiTempLabel(NULL);
10045     pic14_emitcode("mov","dptr,#%05d_DS_",jtab->key+100);
10046     pic14_emitcode("jmp","@a+dptr");
10047     pic14_emitcode("","%05d_DS_:",jtab->key+100);
10048
10049     emitpcode(POC_MOVLW, popGetHighLabel(jtab->key));
10050     emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
10051     emitpcode(POC_MOVLW, popGetLabel(jtab->key));
10052     emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0));
10053     emitSKPNC;
10054     emitpcode(POC_INCF, popCopyReg(&pc_pclath));
10055     emitpcode(POC_MOVWF, popCopyReg(&pc_pcl));
10056     emitpLabel(jtab->key);
10057
10058     freeAsmop(IC_JTCOND(ic),NULL,ic,TRUE);
10059
10060     /* now generate the jump labels */
10061     for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
10062     jtab = setNextItem(IC_JTLABELS(ic))) {
10063         pic14_emitcode("ljmp","%05d_DS_",jtab->key+100);
10064         emitpcode(POC_GOTO,popGetLabel(jtab->key));
10065
10066     }
10067
10068 }
10069
10070 /*-----------------------------------------------------------------*/
10071 /* genMixedOperation - gen code for operators between mixed types  */
10072 /*-----------------------------------------------------------------*/
10073 /*
10074 TSD - Written for the PIC port - but this unfortunately is buggy.
10075 This routine is good in that it is able to efficiently promote
10076 types to different (larger) sizes. Unfortunately, the temporary
10077 variables that are optimized out by this routine are sometimes
10078 used in other places. So until I know how to really parse the
10079 iCode tree, I'm going to not be using this routine :(.
10080 */
10081 static int genMixedOperation (iCode *ic)
10082 {
10083     FENTRY;
10084 #if 0
10085     operand *result = IC_RESULT(ic);
10086     sym_link *ctype = operandType(IC_LEFT(ic));
10087     operand *right = IC_RIGHT(ic);
10088     int ret = 0;
10089     int big,small;
10090     int offset;
10091
10092     iCode *nextic;
10093     operand *nextright=NULL,*nextleft=NULL,*nextresult=NULL;
10094
10095     pic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
10096
10097     nextic = ic->next;
10098     if(!nextic)
10099         return 0;
10100
10101     nextright = IC_RIGHT(nextic);
10102     nextleft  = IC_LEFT(nextic);
10103     nextresult = IC_RESULT(nextic);
10104
10105     aopOp(right,ic,FALSE);
10106     aopOp(result,ic,FALSE);
10107     aopOp(nextright,  nextic, FALSE);
10108     aopOp(nextleft,   nextic, FALSE);
10109     aopOp(nextresult, nextic, FALSE);
10110
10111     if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_RIGHT(nextic)))) {
10112
10113         operand *t = right;
10114         right = nextright;
10115         nextright = t;
10116
10117         pic14_emitcode(";remove right +","");
10118
10119     } else   if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_LEFT(nextic)))) {
10120     /*
10121     operand *t = right;
10122     right = nextleft;
10123     nextleft = t;
10124         */
10125         pic14_emitcode(";remove left +","");
10126     } else
10127         return 0;
10128
10129     big = AOP_SIZE(nextleft);
10130     small = AOP_SIZE(nextright);
10131
10132     switch(nextic->op) {
10133
10134     case '+':
10135         pic14_emitcode(";optimize a +","");
10136         /* if unsigned or not an integral type */
10137         if (AOP_TYPE(IC_LEFT(nextic)) == AOP_CRY) {
10138             pic14_emitcode(";add a bit to something","");
10139         } else {
10140
10141             pic14_emitcode("movf","%s,w",AOP(nextright)->aopu.aop_dir);
10142
10143             if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ) {
10144                 pic14_emitcode("addwf","%s,w",AOP(nextleft)->aopu.aop_dir);
10145                 pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(nextic)),0,FALSE,FALSE));
10146             } else
10147                 pic14_emitcode("addwf","%s,f",AOP(nextleft)->aopu.aop_dir);
10148
10149             offset = 0;
10150             while(--big) {
10151
10152                 offset++;
10153
10154                 if(--small) {
10155                     if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
10156                         pic14_emitcode("movf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
10157                         pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
10158                     }
10159
10160                     pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
10161                     emitSKPNC;
10162                     pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
10163                         AOP(IC_RIGHT(nextic))->aopu.aop_dir,
10164                         AOP(IC_RIGHT(nextic))->aopu.aop_dir);
10165                     pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
10166                     pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE));
10167
10168                 } else {
10169                     pic14_emitcode("rlf","known_zero,w");
10170
10171                     /*
10172                     if right is signed
10173                     btfsc  right,7
10174                     addlw ff
10175                     */
10176                     if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
10177                         pic14_emitcode("addwf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
10178                         pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
10179                     } else {
10180                         pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
10181                     }
10182                 }
10183             }
10184             ret = 1;
10185         }
10186     }
10187     ret = 1;
10188
10189 release:
10190     freeAsmop(right,NULL,ic,TRUE);
10191     freeAsmop(result,NULL,ic,TRUE);
10192     freeAsmop(nextright,NULL,ic,TRUE);
10193     freeAsmop(nextleft,NULL,ic,TRUE);
10194     if(ret)
10195         nextic->generated = 1;
10196
10197     return ret;
10198 #else
10199     return 0;
10200 #endif
10201 }
10202 /*-----------------------------------------------------------------*/
10203 /* genCast - gen code for casting                                  */
10204 /*-----------------------------------------------------------------*/
10205 static void genCast (iCode *ic)
10206 {
10207     operand *result = IC_RESULT(ic);
10208     sym_link *restype = operandType(result);
10209     sym_link *rtype = operandType(IC_RIGHT(ic));
10210     operand *right = IC_RIGHT(ic);
10211     int size, offset ;
10212
10213     FENTRY;
10214     DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
10215     /* if they are equivalent then do nothing */
10216     if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
10217         return ;
10218
10219     aopOp(right,ic,FALSE) ;
10220     aopOp(result,ic,FALSE);
10221
10222     DEBUGpic14_AopType(__LINE__,NULL,right,result);
10223
10224     /* if the result is a bit */
10225     if (AOP_TYPE(result) == AOP_CRY) {
10226         assert(!"assigning to bit variables is not supported");
10227     }
10228
10229     if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) {
10230         int offset = 1;
10231         size = AOP_SIZE(result);
10232
10233         DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
10234
10235         emitpcode(POC_CLRF,   popGet(AOP(result),0));
10236         emitpcode(POC_BTFSC,  popGet(AOP(right),0));
10237         emitpcode(POC_INCF,   popGet(AOP(result),0));
10238
10239         while (size--)
10240             emitpcode(POC_CLRF,   popGet(AOP(result),offset++));
10241
10242         goto release;
10243     }
10244
10245     if (IS_PTR(restype))
10246     {
10247       operand *result = IC_RESULT(ic);
10248       //operand *left = IC_LEFT(ic);
10249       operand *right = IC_RIGHT(ic);
10250       int tag = 0xff;
10251
10252       /* copy common part */
10253       int max, size = AOP_SIZE(result);
10254       if (size > AOP_SIZE(right)) size = AOP_SIZE(right);
10255       DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
10256
10257       /* warn if we discard generic opinter tag */
10258       if (!IS_GENPTR(restype) && IS_GENPTR(rtype) && (AOP_SIZE(result) < AOP_SIZE(right)))
10259       {
10260         //fprintf (stderr, "%s:%u: discarding generic pointer type tag\n", __FUNCTION__, __LINE__);
10261       } // if
10262
10263       max = size;
10264       while (size--)
10265       {
10266         mov2w_op (right, size);
10267         movwf (AOP(result), size);
10268       } // while
10269
10270       /* upcast into generic pointer type? */
10271       if (IS_GENPTR(restype)
10272         && (size < AOP_SIZE(result))
10273         && (!IS_GENPTR(rtype) || AOP_SIZE(right) < GPTRSIZE))
10274       {
10275         //fprintf (stderr, "%s:%u: must determine pointer type\n", __FUNCTION__, __LINE__);
10276         if (IS_PTR(rtype))
10277         {
10278           switch (DCL_TYPE(rtype))
10279           {
10280           case POINTER: /* __data */
10281           case FPOINTER:    /* __data */
10282         assert (AOP_SIZE(right) == 2);
10283         tag = GPTRTAG_DATA;
10284         break;
10285
10286           case CPOINTER:    /* __code */
10287         assert (AOP_SIZE(right) == 2);
10288         tag = GPTRTAG_CODE;
10289         break;
10290
10291           case GPOINTER:    /* unknown destination, __data or __code */
10292         /* assume __data space (address of immediate) */
10293         assert (AOP_TYPE(right) == AOP_PCODE && AOP(right)->aopu.pcop->type == PO_IMMEDIATE);
10294         if (AOP(right)->code)
10295           tag = GPTRTAG_CODE;
10296         else
10297           tag = GPTRTAG_DATA;
10298         break;
10299
10300           default:
10301         assert (!"unhandled pointer type");
10302           } // switch
10303         } else {
10304           /* convert other values into pointers to __data space */
10305           tag = GPTRTAG_DATA;
10306         }
10307
10308         assert (AOP_SIZE(result) == 3);
10309         if (tag == 0) {
10310           emitpcode(POC_CLRF, popGet(AOP(result), 2));
10311         } else {
10312           emitpcode(POC_MOVLW, popGetLit(tag));
10313           movwf(AOP(result), 2);
10314         }
10315       } else {
10316         addSign(result, max, 0);
10317       } // if
10318       goto release;
10319     }
10320
10321     /* if they are the same size : or less */
10322     if (AOP_SIZE(result) <= AOP_SIZE(right)) {
10323
10324         /* if they are in the same place */
10325         if (pic14_sameRegs(AOP(right),AOP(result)))
10326             goto release;
10327
10328         DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
10329         if (IS_PTR_CONST(rtype))
10330             DEBUGpic14_emitcode ("; ***","%d - right is const pointer",__LINE__);
10331         if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
10332             DEBUGpic14_emitcode ("; ***","%d - result is const pointer",__LINE__);
10333
10334         if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
10335             emitpcode(POC_MOVLW, popGetAddr(AOP(right),0,0));
10336             emitpcode(POC_MOVWF, popGet(AOP(result),0));
10337             emitpcode(POC_MOVLW, popGetAddr(AOP(right),1,0));
10338             emitpcode(POC_MOVWF, popGet(AOP(result),1));
10339             if(AOP_SIZE(result) <2)
10340                 fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
10341
10342         } else {
10343
10344             /* if they in different places then copy */
10345             size = AOP_SIZE(result);
10346             offset = 0 ;
10347             while (size--) {
10348                 emitpcode(POC_MOVFW, popGet(AOP(right),offset));
10349                 emitpcode(POC_MOVWF, popGet(AOP(result),offset));
10350
10351                 //aopPut(AOP(result),
10352                 // aopGet(AOP(right),offset,FALSE,FALSE),
10353                 // offset);
10354
10355                 offset++;
10356             }
10357         }
10358         goto release;
10359     }
10360
10361     /* so we now know that the size of destination is greater
10362     than the size of the source.
10363     Now, if the next iCode is an operator then we might be
10364     able to optimize the operation without performing a cast.
10365     */
10366     if(0 && genMixedOperation(ic)) {
10367         /* XXX: cannot optimize: must copy regs! */
10368         goto release;
10369     }
10370
10371     /* we move to result for the size of source */
10372     size = AOP_SIZE(right);
10373     offset = 0 ;
10374     while (size--) {
10375         emitpcode(POC_MOVFW,   popGet(AOP(right),offset));
10376         emitpcode(POC_MOVWF,   popGet(AOP(result),offset));
10377         offset++;
10378     }
10379
10380     addSign (result, AOP_SIZE(right), !SPEC_USIGN(rtype));
10381
10382 release:
10383     freeAsmop(right,NULL,ic,TRUE);
10384     freeAsmop(result,NULL,ic,TRUE);
10385
10386 }
10387
10388 /*-----------------------------------------------------------------*/
10389 /* genDjnz - generate decrement & jump if not zero instrucion      */
10390 /*-----------------------------------------------------------------*/
10391 static int genDjnz (iCode *ic, iCode *ifx)
10392 {
10393     symbol *lbl, *lbl1;
10394     FENTRY;
10395     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
10396
10397     if (!ifx)
10398         return 0;
10399
10400         /* if the if condition has a false label
10401     then we cannot save */
10402     if (IC_FALSE(ifx))
10403         return 0;
10404
10405         /* if the minus is not of the form
10406     a = a - 1 */
10407     if (!isOperandEqual(IC_RESULT(ic),IC_LEFT(ic)) ||
10408         !IS_OP_LITERAL(IC_RIGHT(ic)))
10409         return 0;
10410
10411     if (operandLitValue(IC_RIGHT(ic)) != 1)
10412         return 0;
10413
10414         /* if the size of this greater than one then no
10415     saving */
10416     if (getSize(operandType(IC_RESULT(ic))) > 1)
10417         return 0;
10418
10419     /* otherwise we can save BIG */
10420     lbl = newiTempLabel(NULL);
10421     lbl1= newiTempLabel(NULL);
10422
10423     aopOp(IC_RESULT(ic),ic,FALSE);
10424
10425     if (IS_AOP_PREG(IC_RESULT(ic))) {
10426         pic14_emitcode("dec","%s",
10427             aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
10428         pic14_emitcode("mov","a,%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
10429         pic14_emitcode("jnz","%05d_DS_",lbl->key+100);
10430     } else {
10431
10432
10433         emitpcode(POC_DECFSZ,popGet(AOP(IC_RESULT(ic)),0));
10434         emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
10435
10436         pic14_emitcode("decfsz","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
10437         pic14_emitcode ("goto","_%05d_DS_",IC_TRUE(ifx)->key+100 + labelOffset);
10438
10439     }
10440     /*     pic14_emitcode ("sjmp","%05d_DS_",lbl1->key+100); */
10441     /*     pic14_emitcode ("","%05d_DS_:",lbl->key+100); */
10442     /*     pic14_emitcode ("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100); */
10443     /*     pic14_emitcode ("","%05d_DS_:",lbl1->key+100); */
10444
10445
10446     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
10447     ifx->generated = 1;
10448     return 1;
10449 }
10450
10451 /*-----------------------------------------------------------------*/
10452 /* genReceive - generate code for a receive iCode                  */
10453 /*-----------------------------------------------------------------*/
10454 static void genReceive (iCode *ic)
10455 {
10456     FENTRY;
10457     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
10458
10459     if (isOperandInFarSpace(IC_RESULT(ic)) &&
10460         ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
10461         IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
10462
10463         int size = getSize(operandType(IC_RESULT(ic)));
10464         int offset =  fReturnSizePic - size;
10465         while (size--) {
10466             pic14_emitcode ("push","%s", (strcmp(fReturn[fReturnSizePic - offset - 1],"a") ?
10467                 fReturn[fReturnSizePic - offset - 1] : "acc"));
10468             offset++;
10469         }
10470         aopOp(IC_RESULT(ic),ic,FALSE);
10471         size = AOP_SIZE(IC_RESULT(ic));
10472         offset = 0;
10473         while (size--) {
10474             pic14_emitcode ("pop","acc");
10475             aopPut (AOP(IC_RESULT(ic)),"a",offset++);
10476         }
10477
10478     } else {
10479         _G.accInUse++;
10480         aopOp(IC_RESULT(ic),ic,FALSE);
10481         _G.accInUse--;
10482         GpsuedoStkPtr = ic->parmBytes; // address used arg on stack
10483         assignResultValue(IC_RESULT(ic));
10484     }
10485
10486     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
10487 }
10488
10489 /*-----------------------------------------------------------------*/
10490 /* genDummyRead - generate code for dummy read of volatiles        */
10491 /*-----------------------------------------------------------------*/
10492 static void
10493 genDummyRead (iCode * ic)
10494 {
10495     FENTRY;
10496     pic14_emitcode ("; genDummyRead","");
10497     pic14_emitcode ("; not implemented","");
10498
10499     ic = ic;
10500 }
10501
10502 /*-----------------------------------------------------------------*/
10503 /* genpic14Code - generate code for pic14 based controllers        */
10504 /*-----------------------------------------------------------------*/
10505 /*
10506 * At this point, ralloc.c has gone through the iCode and attempted
10507 * to optimize in a way suitable for a PIC. Now we've got to generate
10508 * PIC instructions that correspond to the iCode.
10509 *
10510 * Once the instructions are generated, we'll pass through both the
10511 * peep hole optimizer and the pCode optimizer.
10512 *-----------------------------------------------------------------*/
10513
10514 void genpic14Code (iCode *lic)
10515 {
10516     iCode *ic;
10517     int cln = 0;
10518     const char *cline;
10519
10520     FENTRY;
10521     lineHead = lineCurr = NULL;
10522
10523     pb = newpCodeChain(GcurMemmap,0,newpCodeCharP("; Starting pCode block"));
10524     addpBlock(pb);
10525
10526     /* if debug information required */
10527     if (options.debug && debugFile && currFunc) {
10528         debugFile->writeFunction (currFunc, lic);
10529     }
10530
10531
10532     for (ic = lic ; ic ; ic = ic->next ) {
10533
10534         //DEBUGpic14_emitcode(";ic","");
10535         //fprintf (stderr, "in ic loop\n");
10536         //pic14_emitcode ("", ";\t%s:%d: %s", ic->filename,
10537         //ic->lineno, printCLine(ic->filename, ic->lineno));
10538
10539         if (!options.noCcodeInAsm && (cln != ic->lineno)) {
10540           cln = ic->lineno;
10541           //fprintf (stderr, "%s\n", printCLine (ic->filename, ic->lineno));
10542           cline = printCLine (ic->filename, ic->lineno);
10543           if (!cline || strlen (cline) == 0) cline = printCLine (ic->filename, ic->lineno);
10544           addpCode2pBlock (pb, newpCodeCSource (ic->lineno, ic->filename, cline));
10545           //emitpComment ("[C-SRC] %s:%d: %s", ic->filename, cln, cline);
10546         }
10547
10548         if (options.iCodeInAsm) {
10549           const char *iLine = printILine(ic);
10550           emitpComment ("[ICODE] %s:%d: %s", ic->filename, ic->lineno, printILine (ic));
10551                   dbuf_free(iLine);
10552         }
10553         /* if the result is marked as
10554         spilt and rematerializable or code for
10555         this has already been generated then
10556         do nothing */
10557         if (resultRemat(ic) || ic->generated )
10558             continue ;
10559
10560         /* depending on the operation */
10561         switch (ic->op) {
10562         case '!' :
10563             genNot(ic);
10564             break;
10565
10566         case '~' :
10567             genCpl(ic);
10568             break;
10569
10570         case UNARYMINUS:
10571             genUminus (ic);
10572             break;
10573
10574         case IPUSH:
10575             genIpush (ic);
10576             break;
10577
10578         case IPOP:
10579             /* IPOP happens only when trying to restore a
10580             spilt live range, if there is an ifx statement
10581             following this pop then the if statement might
10582             be using some of the registers being popped which
10583             would destory the contents of the register so
10584             we need to check for this condition and handle it */
10585             if (ic->next            &&
10586                 ic->next->op == IFX &&
10587                 regsInCommon(IC_LEFT(ic),IC_COND(ic->next)))
10588                 genIfx (ic->next,ic);
10589             else
10590                 genIpop (ic);
10591             break;
10592
10593         case CALL:
10594             genCall (ic);
10595             break;
10596
10597         case PCALL:
10598             genPcall (ic);
10599             break;
10600
10601         case FUNCTION:
10602             genFunction (ic);
10603             break;
10604
10605         case ENDFUNCTION:
10606             genEndFunction (ic);
10607             break;
10608
10609         case RETURN:
10610             genRet (ic);
10611             break;
10612
10613         case LABEL:
10614             genLabel (ic);
10615             break;
10616
10617         case GOTO:
10618             genGoto (ic);
10619             break;
10620
10621         case '+' :
10622             genPlus (ic) ;
10623             break;
10624
10625         case '-' :
10626             if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
10627                 genMinus (ic);
10628             break;
10629
10630         case '*' :
10631             genMult (ic);
10632             break;
10633
10634         case '/' :
10635             genDiv (ic) ;
10636             break;
10637
10638         case '%' :
10639             genMod (ic);
10640             break;
10641
10642         case '>' :
10643             genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));
10644             break;
10645
10646         case '<' :
10647             genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
10648             break;
10649
10650         case LE_OP:
10651         case GE_OP:
10652         case NE_OP:
10653
10654             /* note these two are xlated by algebraic equivalence
10655             during parsing SDCC.y */
10656             werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
10657                 "got '>=' or '<=' shouldn't have come here");
10658             break;
10659
10660         case EQ_OP:
10661             genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
10662             break;
10663
10664         case AND_OP:
10665             genAndOp (ic);
10666             break;
10667
10668         case OR_OP:
10669             genOrOp (ic);
10670             break;
10671
10672         case '^' :
10673             genXor (ic,ifxForOp(IC_RESULT(ic),ic));
10674             break;
10675
10676         case '|' :
10677             genOr (ic,ifxForOp(IC_RESULT(ic),ic));
10678             break;
10679
10680         case BITWISEAND:
10681             genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
10682             break;
10683
10684         case INLINEASM:
10685             genInline (ic);
10686             break;
10687
10688         case RRC:
10689             genRRC (ic);
10690             break;
10691
10692         case RLC:
10693             genRLC (ic);
10694             break;
10695
10696         case GETHBIT:
10697             genGetHbit (ic);
10698             break;
10699
10700         case LEFT_OP:
10701             genLeftShift (ic);
10702             break;
10703
10704         case RIGHT_OP:
10705             genRightShift (ic);
10706             break;
10707
10708         case GET_VALUE_AT_ADDRESS:
10709             genPointerGet(ic);
10710             break;
10711
10712         case '=' :
10713             if (POINTER_SET(ic))
10714                 genPointerSet(ic);
10715             else
10716                 genAssign(ic);
10717             break;
10718
10719         case IFX:
10720             genIfx (ic,NULL);
10721             break;
10722
10723         case ADDRESS_OF:
10724             genAddrOf (ic);
10725             break;
10726
10727         case JUMPTABLE:
10728             genJumpTab (ic);
10729             break;
10730
10731         case CAST:
10732             genCast (ic);
10733             break;
10734
10735         case RECEIVE:
10736             genReceive(ic);
10737             break;
10738
10739         case SEND:
10740             addSet(&_G.sendSet,ic);
10741             break;
10742
10743         case DUMMY_READ_VOLATILE:
10744             genDummyRead (ic);
10745             break;
10746
10747         default :
10748             fprintf(stderr, "UNHANDLED iCode: "); piCode(ic, stderr);
10749             ic = ic;
10750             break;
10751         }
10752     }
10753
10754
10755     /* now we are ready to call the
10756     peep hole optimizer */
10757     if (!options.nopeep) {
10758         peepHole (&lineHead);
10759     }
10760     /* now do the actual printing */
10761     printLine (lineHead,codeOutBuf);
10762
10763 #ifdef PCODE_DEBUG
10764     DFPRINTF((stderr,"printing pBlock\n\n"));
10765     printpBlock(stdout,pb);
10766 #endif
10767
10768     return;
10769 }
10770
10771 /* This is not safe, as a AOP_PCODE/PO_IMMEDIATE might be used both as literal
10772  * (meaning: representing its own address) or not (referencing its contents).
10773  * This can only be decided based on the operand's type. */
10774 int
10775 aop_isLitLike (asmop *aop)
10776 {
10777   assert (aop);
10778   if (aop->type == AOP_LIT) return 1;
10779 if (aop->type == AOP_IMMD) return 1;
10780   if ((aop->type == AOP_PCODE) &&
10781         ((aop->aopu.pcop->type == PO_LITERAL)))
10782   {
10783     /* this should be treated like a literal/immediate (use MOVLW/ADDLW/SUBLW
10784      * instead of MOVFW/ADDFW/SUBFW, use popGetAddr instead of popGet) */
10785     return 1;
10786   }
10787   return 0;
10788 }
10789
10790 int
10791 op_isLitLike (operand *op)
10792 {
10793   assert (op);
10794   if (aop_isLitLike (AOP(op))) return 1;
10795   if (IS_FUNC(OP_SYM_TYPE(op))) return 1;
10796   if (IS_PTR(OP_SYM_TYPE(op)) && AOP_TYPE(op) == AOP_PCODE && AOP(op)->aopu.pcop->type == PO_IMMEDIATE) return 1;
10797   return 0;
10798 }
10799