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

   1 /*-------------------------------------------------------------------------
   2   genarith.c - source file for code generation - arithmetic
   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
   9   This program is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU General Public License as published by the
  11   Free Software Foundation; either version 2, or (at your option) any
  12   later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19   You should have received a copy of the GNU General Public License
  20   along with this program; if not, write to the Free Software
  21   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22
  23   In other words, you are welcome to use, share and improve this program.
  24   You are forbidden to forbid anyone else to use, share and improve
  25   what you give them.   Help stamp out software-hoarding!
  26
  27   Notes:
  28   000123 mlh    Moved aopLiteral to SDCCglue.c to help the split
  29                 Made everything static
  30 -------------------------------------------------------------------------*/
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36 #include "SDCCglobl.h"
  37 #include "newalloc.h"
  38
  39 #if defined(_MSC_VER) && (_MSC_VER < 1300)
  40 #define __FUNCTION__            __FILE__
  41 #endif
  42
  43 #include "common.h"
  44 #include "SDCCpeeph.h"
  45 #include "ralloc.h"
  46 #include "pcode.h"
  47 #include "gen.h"
  48
  49
  50 #define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0xff)
  51 void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *result);
  52
  53 const char *AopType(short type)
  54 {
  55   switch(type) {
  56   case AOP_LIT:
  57     return "AOP_LIT";
  58     break;
  59   case AOP_REG:
  60     return "AOP_REG";
  61     break;
  62   case AOP_DIR:
  63     return "AOP_DIR";
  64     break;
  65   case AOP_DPTR:
  66     return "AOP_DPTR";
  67     break;
  68   case AOP_DPTR2:
  69     return "AOP_DPTR2";
  70     break;
  71   case AOP_R0:
  72     return "AOP_R0";
  73     break;
  74   case AOP_R1:
  75     return "AOP_R1";
  76     break;
  77   case AOP_STK:
  78     return "AOP_STK";
  79     break;
  80   case AOP_IMMD:
  81     return "AOP_IMMD";
  82     break;
  83   case AOP_STR:
  84     return "AOP_STR";
  85     break;
  86   case AOP_CRY:
  87     return "AOP_CRY";
  88     break;
  89   case AOP_ACC:
  90     return "AOP_ACC";
  91     break;
  92   case AOP_PCODE:
  93     return "AOP_PCODE";
  94     break;
  95   }
  96
  97   return "BAD TYPE";
  98 }
  99
 100 const char *pCodeOpType(  pCodeOp *pcop)
 101 {
 102
 103   if(pcop) {
 104
 105     switch(pcop->type) {
 106
 107     case  PO_NONE:
 108       return "PO_NONE";
 109     case  PO_W:
 110       return  "PO_W";
 111     case  PO_STATUS:
 112       return  "PO_STATUS";
 113     case  PO_FSR:
 114       return  "PO_FSR";
 115     case  PO_INDF:
 116       return  "PO_INDF";
 117     case  PO_INTCON:
 118       return  "PO_INTCON";
 119     case  PO_GPR_REGISTER:
 120       return  "PO_GPR_REGISTER";
 121     case  PO_GPR_POINTER:
 122       return  "PO_GPR_POINTER";
 123     case  PO_GPR_BIT:
 124       return  "PO_GPR_BIT";
 125     case  PO_GPR_TEMP:
 126       return  "PO_GPR_TEMP";
 127     case  PO_SFR_REGISTER:
 128       return  "PO_SFR_REGISTER";
 129     case  PO_PCL:
 130       return  "PO_PCL";
 131     case  PO_PCLATH:
 132       return  "PO_PCLATH";
 133     case  PO_LITERAL:
 134       return  "PO_LITERAL";
 135     case  PO_IMMEDIATE:
 136       return  "PO_IMMEDIATE";
 137     case  PO_DIR:
 138       return  "PO_DIR";
 139     case  PO_CRY:
 140       return  "PO_CRY";
 141     case  PO_BIT:
 142       return  "PO_BIT";
 143     case  PO_STR:
 144       return  "PO_STR";
 145     case  PO_LABEL:
 146       return  "PO_LABEL";
 147     case  PO_WILD:
 148       return  "PO_WILD";
 149     }
 150   }
 151
 152   return "BAD PO_TYPE";
 153 }
 154
 155 /*-----------------------------------------------------------------*/
 156 /* genPlusIncr :- does addition with increment if possible         */
 157 /*-----------------------------------------------------------------*/
 158 bool genPlusIncr (iCode *ic)
 159 {
 160     unsigned int icount ;
 161     unsigned int size = pic14_getDataSize(IC_RESULT(ic));
 162
 163     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 164     DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
 165                          AopType(AOP_TYPE(IC_RESULT(ic))),
 166                          AopType(AOP_TYPE(IC_LEFT(ic))),
 167                          AopType(AOP_TYPE(IC_RIGHT(ic))));
 168
 169     /* will try to generate an increment */
 170     /* if the right side is not a literal
 171        we cannot */
 172     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
 173         return FALSE ;
 174
 175     DEBUGpic14_emitcode ("; ","%s  %d",__FUNCTION__,__LINE__);
 176     /* if the literal value of the right hand side
 177        is greater than 1 then it is faster to add */
 178     if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
 179         return FALSE ;
 180
 181     /* if increment 16 bits in register */
 182     if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
 183         (icount == 1)) {
 184
 185       int offset = MSB16;
 186
 187       emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB));
 188       //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
 189
 190       while(--size) {
 191         emitSKPNZ;
 192         emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
 193         //pic14_emitcode(" incf","%s,f",aopGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
 194       }
 195
 196       return TRUE;
 197     }
 198
 199     DEBUGpic14_emitcode ("; ","%s  %d",__FUNCTION__,__LINE__);
 200     /* if left is in accumulator  - probably a bit operation*/
 201     if( strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a")  &&
 202         (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) ) {
 203
 204       emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
 205       pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
 206                AOP(IC_RESULT(ic))->aopu.aop_dir,
 207                AOP(IC_RESULT(ic))->aopu.aop_dir);
 208       if(icount)
 209         emitpcode(POC_XORLW,popGetLit(1));
 210       //pic14_emitcode("xorlw","1");
 211       else
 212         emitpcode(POC_ANDLW,popGetLit(1));
 213       //pic14_emitcode("andlw","1");
 214
 215       emitSKPZ;
 216       emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
 217       pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
 218                AOP(IC_RESULT(ic))->aopu.aop_dir,
 219                AOP(IC_RESULT(ic))->aopu.aop_dir);
 220
 221       return TRUE;
 222     }
 223
 224
 225
 226     /* if the sizes are greater than 1 then we cannot */
 227     if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
 228         AOP_SIZE(IC_LEFT(ic)) > 1   )
 229         return FALSE ;
 230
 231     /* If we are incrementing the same register by two: */
 232
 233     if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
 234
 235       while (icount--)
 236         emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
 237       //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 238
 239       return TRUE ;
 240     }
 241
 242     DEBUGpic14_emitcode ("; ","couldn't increment ");
 243
 244     return FALSE ;
 245 }
 246
 247 /*-----------------------------------------------------------------*/
 248 /* pic14_outBitAcc - output a bit in acc                                 */
 249 /*-----------------------------------------------------------------*/
 250 void pic14_outBitAcc(operand *result)
 251 {
 252     symbol *tlbl = newiTempLabel(NULL);
 253     /* if the result is a bit */
 254     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 255
 256     if (AOP_TYPE(result) == AOP_CRY){
 257         aopPut(AOP(result),"a",0);
 258     }
 259     else {
 260         pic14_emitcode("jz","%05d_DS_",tlbl->key+100);
 261         pic14_emitcode("mov","a,#01");
 262         pic14_emitcode("","%05d_DS_:",tlbl->key+100);
 263         pic14_outAcc(result);
 264     }
 265 }
 266
 267 /*-----------------------------------------------------------------*/
 268 /* genPlusBits - generates code for addition of two bits           */
 269 /*-----------------------------------------------------------------*/
 270 void genPlusBits (iCode *ic)
 271 {
 272
 273   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 274
 275   DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
 276                        AopType(AOP_TYPE(IC_RESULT(ic))),
 277                        AopType(AOP_TYPE(IC_LEFT(ic))),
 278                        AopType(AOP_TYPE(IC_RIGHT(ic))));
 279   /*
 280     The following block of code will add two bits.
 281     Note that it'll even work if the destination is
 282     the carry (C in the status register).
 283     It won't work if the 'Z' bit is a source or destination.
 284   */
 285
 286   /* If the result is stored in the accumulator (w) */
 287   //if(strcmp(aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),"a") == 0 ) {
 288   switch(AOP_TYPE(IC_RESULT(ic))) {
 289   case AOP_ACC:
 290     emitpcode(POC_CLRW, NULL);
 291     emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
 292     emitpcode(POC_XORLW, popGetLit(1));
 293     emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
 294     emitpcode(POC_XORLW, popGetLit(1));
 295
 296     pic14_emitcode("clrw","");
 297     pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 298                    AOP(IC_RIGHT(ic))->aopu.aop_dir,
 299                    AOP(IC_RIGHT(ic))->aopu.aop_dir);
 300     pic14_emitcode("xorlw","1");
 301     pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 302                    AOP(IC_LEFT(ic))->aopu.aop_dir,
 303                    AOP(IC_LEFT(ic))->aopu.aop_dir);
 304     pic14_emitcode("xorlw","1");
 305     break;
 306   case AOP_REG:
 307     emitpcode(POC_MOVLW, popGetLit(0));
 308     emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
 309     emitpcode(POC_XORLW, popGetLit(1));
 310     emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
 311     emitpcode(POC_XORLW, popGetLit(1));
 312     emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
 313     break;
 314   default:
 315     emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
 316     emitpcode(POC_BCF,   popGet(AOP(IC_RESULT(ic)),0));
 317     emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
 318     emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
 319     emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
 320     emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
 321
 322     pic14_emitcode("movlw","(1 << (%s & 7))",
 323                    AOP(IC_RESULT(ic))->aopu.aop_dir,
 324                    AOP(IC_RESULT(ic))->aopu.aop_dir);
 325     pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
 326                    AOP(IC_RESULT(ic))->aopu.aop_dir,
 327                    AOP(IC_RESULT(ic))->aopu.aop_dir);
 328     pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 329                    AOP(IC_RIGHT(ic))->aopu.aop_dir,
 330                    AOP(IC_RIGHT(ic))->aopu.aop_dir);
 331     pic14_emitcode("xorwf","(%s >>3),f",
 332                    AOP(IC_RESULT(ic))->aopu.aop_dir);
 333     pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 334                    AOP(IC_LEFT(ic))->aopu.aop_dir,
 335                    AOP(IC_LEFT(ic))->aopu.aop_dir);
 336     pic14_emitcode("xorwf","(%s>>3),f",
 337                    AOP(IC_RESULT(ic))->aopu.aop_dir);
 338     break;
 339   }
 340
 341 }
 342
 343 #if 0
 344 /* This is the original version of this code.
 345  *
 346  * This is being kept around for reference,
 347  * because I am not entirely sure I got it right...
 348  */
 349 static void adjustArithmeticResult(iCode *ic)
 350 {
 351     if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
 352         AOP_SIZE(IC_LEFT(ic)) == 3   &&
 353         !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
 354         aopPut(AOP(IC_RESULT(ic)),
 355                aopGet(AOP(IC_LEFT(ic)),2,FALSE,FALSE),
 356                2);
 357
 358     if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
 359         AOP_SIZE(IC_RIGHT(ic)) == 3   &&
 360         !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
 361         aopPut(AOP(IC_RESULT(ic)),
 362                aopGet(AOP(IC_RIGHT(ic)),2,FALSE,FALSE),
 363                2);
 364
 365     if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
 366         AOP_SIZE(IC_LEFT(ic)) < 3    &&
 367         AOP_SIZE(IC_RIGHT(ic)) < 3   &&
 368         !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
 369         !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
 370         char buffer[5];
 371         sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
 372         aopPut(AOP(IC_RESULT(ic)),buffer,2);
 373     }
 374 }
 375 //#else
 376 /* This is the pure and virtuous version of this code.
 377  * I'm pretty certain it's right, but not enough to toss the old
 378  * code just yet...
 379  */
 380 static void adjustArithmeticResult(iCode *ic)
 381 {
 382     if (opIsGptr(IC_RESULT(ic)) &&
 383         opIsGptr(IC_LEFT(ic))   &&
 384         !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
 385     {
 386         aopPut(AOP(IC_RESULT(ic)),
 387                aopGet(AOP(IC_LEFT(ic)), GPTRSIZE - 1,FALSE,FALSE),
 388                GPTRSIZE - 1);
 389     }
 390
 391     if (opIsGptr(IC_RESULT(ic)) &&
 392         opIsGptr(IC_RIGHT(ic))   &&
 393         !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
 394     {
 395         aopPut(AOP(IC_RESULT(ic)),
 396                aopGet(AOP(IC_RIGHT(ic)),GPTRSIZE - 1,FALSE,FALSE),
 397                GPTRSIZE - 1);
 398     }
 399
 400     if (opIsGptr(IC_RESULT(ic))            &&
 401         AOP_SIZE(IC_LEFT(ic)) < GPTRSIZE   &&
 402         AOP_SIZE(IC_RIGHT(ic)) < GPTRSIZE  &&
 403          !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
 404          !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
 405          char buffer[5];
 406          sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
 407          aopPut(AOP(IC_RESULT(ic)),buffer,GPTRSIZE - 1);
 408      }
 409 }
 410 #endif
 411
 412 /*-----------------------------------------------------------------*/
 413 /* genAddlit - generates code for addition                         */
 414 /*-----------------------------------------------------------------*/
 415 static void genAddLit2byte (operand *result, int offr, int lit)
 416 {
 417
 418   switch(lit & 0xff) {
 419   case 0:
 420     break;
 421   case 1:
 422     emitpcode(POC_INCF, popGet(AOP(result),offr));
 423     break;
 424   case 0xff:
 425     emitpcode(POC_DECF, popGet(AOP(result),offr));
 426     break;
 427   default:
 428     emitpcode(POC_MOVLW,popGetLit(lit&0xff));
 429     emitpcode(POC_ADDWF,popGet(AOP(result),offr));
 430   }
 431
 432 }
 433
 434 static void emitMOVWF(operand *reg, int offset)
 435 {
 436   if(!reg)
 437     return;
 438
 439   if (AOP_TYPE(reg) == AOP_ACC) {
 440     DEBUGpic14_emitcode ("; ***","%s  %d ignoring mov into W",__FUNCTION__,__LINE__);
 441     return;
 442   }
 443
 444   emitpcode(POC_MOVWF, popGet(AOP(reg),offset));
 445
 446 }
 447
 448 static void genAddLit (iCode *ic, int lit)
 449 {
 450
 451   int size,same;
 452   int lo;
 453
 454   operand *result;
 455   operand *left;
 456
 457   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 458
 459
 460   left = IC_LEFT(ic);
 461   result = IC_RESULT(ic);
 462   same = pic14_sameRegs(AOP(left), AOP(result));
 463   size = pic14_getDataSize(result);
 464
 465   if(same) {
 466
 467     /* Handle special cases first */
 468     if(size == 1)
 469       genAddLit2byte (result, 0, lit);
 470
 471     else if(size == 2) {
 472       int hi = 0xff & (lit >> 8);
 473       lo = lit & 0xff;
 474
 475       switch(hi) {
 476       case 0:
 477
 478         /* lit = 0x00LL */
 479         DEBUGpic14_emitcode ("; hi = 0","%s  %d",__FUNCTION__,__LINE__);
 480         switch(lo) {
 481         case 0:
 482           break;
 483         case 1:
 484           emitpcode(POC_INCF, popGet(AOP(result),0));
 485           emitSKPNZ;
 486           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 487           break;
 488         case 0xff:
 489           emitpcode(POC_DECF, popGet(AOP(result),0));
 490           emitpcode(POC_INCFSZW, popGet(AOP(result),0));
 491           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 492
 493           break;
 494         default:
 495           emitpcode(POC_MOVLW,popGetLit(lit&0xff));
 496           emitpcode(POC_ADDWF,popGet(AOP(result),0));
 497           emitSKPNC;
 498           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 499
 500
 501         }
 502         break;
 503
 504       case 1:
 505         /* lit = 0x01LL */
 506         DEBUGpic14_emitcode ("; hi = 1","%s  %d",__FUNCTION__,__LINE__);
 507         switch(lo) {
 508         case 0:  /* 0x0100 */
 509           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 510           break;
 511         case 1:  /* 0x0101  */
 512           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 513           emitpcode(POC_INCF, popGet(AOP(result),0));
 514           emitSKPNZ;
 515           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 516           break;
 517         case 0xff: /* 0x01ff */
 518           emitpcode(POC_DECF, popGet(AOP(result),0));
 519           emitpcode(POC_INCFSZW, popGet(AOP(result),0));
 520           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 521           emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 522         }
 523         break;
 524
 525       case 0xff:
 526         DEBUGpic14_emitcode ("; hi = ff","%s  %d",__FUNCTION__,__LINE__);
 527         /* lit = 0xffLL */
 528         switch(lo) {
 529         case 0:  /* 0xff00 */
 530           emitpcode(POC_DECF, popGet(AOP(result),MSB16));
 531           break;
 532         case 1:  /*0xff01 */
 533           emitpcode(POC_INCFSZ, popGet(AOP(result),0));
 534           emitpcode(POC_DECF, popGet(AOP(result),MSB16));
 535           break;
 536 /*      case 0xff: * 0xffff *
 537           emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
 538           emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
 539           emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
 540           break;
 541 */
 542         default:
 543           emitpcode(POC_MOVLW,popGetLit(lo));
 544           emitpcode(POC_ADDWF,popGet(AOP(result),0));
 545           emitSKPC;
 546           emitpcode(POC_DECF, popGet(AOP(result),MSB16));
 547
 548         }
 549
 550         break;
 551
 552       default:
 553         DEBUGpic14_emitcode ("; hi is generic","%d   %s  %d",hi,__FUNCTION__,__LINE__);
 554
 555         /* lit = 0xHHLL */
 556         switch(lo) {
 557         case 0:  /* 0xHH00 */
 558           genAddLit2byte (result, MSB16, hi);
 559           break;
 560         case 1:  /* 0xHH01 */
 561           emitpcode(POC_MOVLW,popGetLit((hi+1)&0xff));
 562           emitpcode(POC_INCFSZ, popGet(AOP(result),0));
 563           emitpcode(POC_MOVLW,popGetLit(hi));
 564           emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
 565           break;
 566 /*      case 0xff: * 0xHHff *
 567           emitpcode(POC_MOVFW, popGet(AOP(result),0,FALSE,FALSE));
 568           emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
 569           emitpcode(POC_MOVLW,popGetLit(hi));
 570           emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
 571           break;
 572 */      default:  /* 0xHHLL */
 573           emitpcode(POC_MOVLW,popGetLit(lo));
 574           emitpcode(POC_ADDWF, popGet(AOP(result),0));
 575           emitpcode(POC_MOVLW,popGetLit(hi));
 576           emitSKPNC;
 577           emitpcode(POC_MOVLW,popGetLit((hi+1) & 0xff));
 578           emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
 579           break;
 580         }
 581
 582       }
 583     } else {
 584       int carry_info = 0;
 585       int offset = 0;
 586       /* size > 2 */
 587       DEBUGpic14_emitcode (";  add lit to long","%s  %d",__FUNCTION__,__LINE__);
 588
 589       while(size--) {
 590         lo = BYTEofLONG(lit,0);
 591
 592         if(carry_info) {
 593           switch(lo) {
 594           case 0:
 595             switch(carry_info) {
 596             case 1:
 597               emitSKPNZ;
 598               emitpcode(POC_INCF, popGet(AOP(result),offset));
 599               break;
 600             case 2:
 601               emitpcode(POC_RLFW, popGet(AOP(result),offset));
 602               emitpcode(POC_ANDLW,popGetLit(1));
 603               emitpcode(POC_ADDWF, popGet(AOP(result),offset));
 604               break;
 605             default: /* carry_info = 3  */
 606               emitSKPNC;
 607               emitpcode(POC_INCF, popGet(AOP(result),offset));
 608               carry_info = 1;
 609               break;
 610             }
 611             break;
 612           case 0xff:
 613             emitpcode(POC_MOVLW,popGetLit(lo));
 614             if(carry_info==1)
 615               emitSKPZ;
 616             else
 617               emitSKPC;
 618             emitpcode(POC_ADDWF, popGet(AOP(result),offset));
 619             break;
 620           default:
 621             emitpcode(POC_MOVLW,popGetLit(lo));
 622             if(carry_info==1)
 623               emitSKPNZ;
 624             else
 625               emitSKPNC;
 626             emitpcode(POC_MOVLW,popGetLit(lo+1));
 627             emitpcode(POC_ADDWF, popGet(AOP(result),offset));
 628             carry_info=2;
 629             break;
 630           }
 631         }else {
 632           /* no carry info from previous step */
 633           /* this means this is the first time to add */
 634           switch(lo) {
 635           case 0:
 636             break;
 637           case 1:
 638             emitpcode(POC_INCF, popGet(AOP(result),offset));
 639             carry_info=1;
 640             break;
 641           default:
 642             emitpcode(POC_MOVLW,popGetLit(lo));
 643             emitpcode(POC_ADDWF, popGet(AOP(result),offset));
 644             if(lit <0x100)
 645               carry_info = 3;  /* Were adding only one byte and propogating the carry */
 646             else
 647               carry_info = 2;
 648             break;
 649           }
 650         }
 651         offset++;
 652         lit >>= 8;
 653       }
 654
 655 /*
 656       lo = BYTEofLONG(lit,0);
 657
 658       if(lit < 0x100) {
 659         if(lo) {
 660           if(lo == 1) {
 661             emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
 662             emitSKPNZ;
 663           } else {
 664             emitpcode(POC_MOVLW,popGetLit(lo));
 665             emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
 666             emitSKPNC;
 667           }
 668           emitpcode(POC_INCF, popGet(AOP(result),1,FALSE,FALSE));
 669           emitSKPNZ;
 670           emitpcode(POC_INCF, popGet(AOP(result),2,FALSE,FALSE));
 671           emitSKPNZ;
 672           emitpcode(POC_INCF, popGet(AOP(result),3,FALSE,FALSE));
 673
 674         }
 675       }
 676     }
 677
 678 */
 679     }
 680   } else {
 681     int offset = 1;
 682     DEBUGpic14_emitcode (";  left and result aren't same","%s  %d",__FUNCTION__,__LINE__);
 683
 684     if(size == 1) {
 685
 686       if(AOP_TYPE(left) == AOP_ACC) {
 687         /* left addend is already in accumulator */
 688         switch(lit & 0xff) {
 689         case 0:
 690           //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 691           emitMOVWF(result,0);
 692           break;
 693         default:
 694           emitpcode(POC_ADDLW, popGetLit(lit & 0xff));
 695           //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 696           emitMOVWF(result,0);
 697         }
 698       } else {
 699         /* left addend is in a register */
 700         switch(lit & 0xff) {
 701         case 0:
 702           emitpcode(POC_MOVFW, popGet(AOP(left),0));
 703           emitMOVWF(result, 0);
 704           //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 705           emitMOVWF(result,0);
 706           break;
 707         case 1:
 708           emitpcode(POC_INCFW, popGet(AOP(left),0));
 709           //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 710           emitMOVWF(result,0);
 711           break;
 712         case 0xff:
 713           emitpcode(POC_DECFW, popGet(AOP(left),0));
 714           //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 715           emitMOVWF(result,0);
 716           break;
 717         default:
 718           emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
 719           emitpcode(POC_ADDFW, popGet(AOP(left),0));
 720           //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 721           emitMOVWF(result,0);
 722         }
 723       }
 724
 725     } else {
 726       int clear_carry=0;
 727
 728       /* left is not the accumulator */
 729       if(lit & 0xff) {
 730         emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
 731         emitpcode(POC_ADDFW, popGet(AOP(left),0));
 732       } else {
 733         emitpcode(POC_MOVFW, popGet(AOP(left),0));
 734         /* We don't know the state of the carry bit at this point */
 735         clear_carry = 1;
 736       }
 737       //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
 738       emitMOVWF(result,0);
 739       while(--size) {
 740
 741         lit >>= 8;
 742         if(lit & 0xff) {
 743           if(clear_carry) {
 744             /* The ls byte of the lit must've been zero - that
 745                means we don't have to deal with carry */
 746
 747             emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
 748             emitpcode(POC_ADDFW,  popGet(AOP(left),offset));
 749             emitpcode(POC_MOVWF, popGet(AOP(left),offset));
 750
 751             clear_carry = 0;
 752
 753           } else {
 754             emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
 755             //emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
 756             emitMOVWF(result,offset);
 757             emitpcode(POC_MOVFW, popGet(AOP(left),offset));
 758             emitSKPNC;
 759             emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
 760             emitpcode(POC_ADDWF,  popGet(AOP(result),offset));
 761           }
 762
 763         } else {
 764           emitpcode(POC_CLRF,  popGet(AOP(result),offset));
 765           emitpcode(POC_RLF,   popGet(AOP(result),offset));
 766           emitpcode(POC_MOVFW, popGet(AOP(left),offset));
 767           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
 768         }
 769         offset++;
 770       }
 771     }
 772   }
 773 }
 774
 775 /*-----------------------------------------------------------------*/
 776 /* genPlus - generates code for addition                           */
 777 /*-----------------------------------------------------------------*/
 778 void genPlus (iCode *ic)
 779 {
 780   int size, offset = 0;
 781
 782   /* special cases :- */
 783   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 784
 785   aopOp (IC_LEFT(ic),ic,FALSE);
 786   aopOp (IC_RIGHT(ic),ic,FALSE);
 787   aopOp (IC_RESULT(ic),ic,TRUE);
 788
 789   DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),IC_RIGHT(ic),IC_RESULT(ic));
 790
 791   /* if literal, literal on the right or
 792      if left requires ACC or right is already
 793      in ACC */
 794
 795   if (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) {
 796     operand *t = IC_RIGHT(ic);
 797     IC_RIGHT(ic) = IC_LEFT(ic);
 798     IC_LEFT(ic) = t;
 799   }
 800
 801   /* if both left & right are in bit space */
 802   if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
 803       AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
 804     genPlusBits (ic);
 805     goto release ;
 806   }
 807
 808   /* if left in bit space & right literal */
 809   if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
 810       AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
 811     /* if result in bit space */
 812     if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
 813       if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
 814         emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
 815         if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
 816           emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
 817         emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
 818       }
 819     } else {
 820       size = pic14_getDataSize(IC_RESULT(ic));
 821       while (size--) {
 822         MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
 823         pic14_emitcode("addc","a,#00  ;%d",__LINE__);
 824         aopPut(AOP(IC_RESULT(ic)),"a",offset++);
 825       }
 826     }
 827     goto release ;
 828   }
 829
 830   /* if I can do an increment instead
 831      of add then GOOD for ME */
 832   if (genPlusIncr (ic) == TRUE)
 833     goto release;
 834
 835   size = pic14_getDataSize(IC_RESULT(ic));
 836
 837   if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
 838     /* Add a literal to something else */
 839     //bool know_W=0;
 840     unsigned lit = (unsigned) floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
 841     //      unsigned l1=0;
 842
 843     //      offset = 0;
 844     DEBUGpic14_emitcode(";","adding lit to something. size %d",size);
 845
 846     genAddLit (ic,  lit);
 847     goto release;
 848
 849   } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
 850
 851     pic14_emitcode(";bitadd","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
 852     pic14_emitcode(";bitadd","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
 853     pic14_emitcode(";bitadd","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 854
 855     /* here we are adding a bit to a char or int */
 856     if(size == 1) {
 857       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
 858
 859         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
 860         emitpcode(POC_INCF ,  popGet(AOP(IC_RESULT(ic)),0));
 861
 862         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 863                        AOP(IC_RIGHT(ic))->aopu.aop_dir,
 864                        AOP(IC_RIGHT(ic))->aopu.aop_dir);
 865         pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 866       } else {
 867
 868         if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
 869           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
 870           emitpcode(POC_XORLW , popGetLit(1));
 871
 872           pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 873                          AOP(IC_RIGHT(ic))->aopu.aop_dir,
 874                          AOP(IC_RIGHT(ic))->aopu.aop_dir);
 875           pic14_emitcode(" xorlw","1");
 876         } else {
 877           emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
 878           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
 879           emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0));
 880
 881           pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
 882           pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 883                          AOP(IC_RIGHT(ic))->aopu.aop_dir,
 884                          AOP(IC_RIGHT(ic))->aopu.aop_dir);
 885           pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
 886         }
 887
 888         if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
 889
 890           if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
 891             emitpcode(POC_ANDLW , popGetLit(1));
 892             emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0));
 893             emitSKPZ;
 894             emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0));
 895           } else {
 896             emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0));
 897             pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 898           }
 899         }
 900       }
 901
 902     } else {
 903       int offset = 1;
 904       DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 905       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
 906         emitCLRZ;
 907         emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
 908         emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),0));
 909
 910         pic14_emitcode("clrz","");
 911
 912         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 913                        AOP(IC_RIGHT(ic))->aopu.aop_dir,
 914                        AOP(IC_RIGHT(ic))->aopu.aop_dir);
 915         pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 916
 917       } else {
 918
 919         emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0));
 920         emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
 921         emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0));
 922         //emitpcode(POC_MOVWF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
 923         emitMOVWF(IC_RIGHT(ic),0);
 924
 925         pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
 926         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
 927                        AOP(IC_RIGHT(ic))->aopu.aop_dir,
 928                        AOP(IC_RIGHT(ic))->aopu.aop_dir);
 929         pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
 930         pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 931
 932       }
 933
 934       while(--size){
 935         emitSKPZ;
 936         emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),offset++));
 937         //pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
 938       }
 939
 940     }
 941
 942   } else {
 943     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 944
 945     /* Add the first bytes */
 946
 947     if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
 948       emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
 949       emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
 950     } else {
 951
 952       if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
 953         emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
 954         if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
 955           emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
 956       } else {
 957
 958         emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
 959
 960         if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
 961           emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
 962         else {
 963           PIC_OPCODE poc = POC_ADDFW;
 964
 965           if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
 966               (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
 967               (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
 968             poc = POC_ADDLW;
 969           emitpcode(poc, popGet(AOP(IC_LEFT(ic)),0));
 970           if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
 971             emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
 972         }
 973       }
 974     }
 975
 976     size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
 977     offset = 1;
 978
 979
 980     if(size){
 981       if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)))) {
 982         if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
 983           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
 984           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE))) {
 985           while(size--){
 986             emitpcode(POC_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset));
 987             emitSKPNC;
 988             emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
 989             emitpcode(POC_ADDLW,   popGet(AOP(IC_LEFT(ic)),offset));
 990             emitpcode(POC_MOVWF,   popGet(AOP(IC_RESULT(ic)),offset));
 991             offset++;
 992           }
 993         } else {
 994           while(size--){
 995             emitpcode(POC_MOVFW,   popGet(AOP(IC_LEFT(ic)),offset));
 996             emitSKPNC;
 997             emitpcode(POC_INCFSZW, popGet(AOP(IC_LEFT(ic)),offset));
 998             emitpcode(POC_ADDWF,   popGet(AOP(IC_RESULT(ic)),offset));
 999             offset++;
1000           }
1001         }
1002       } else {
1003         PIC_OPCODE poc = POC_MOVFW;
1004         if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
1005           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
1006           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
1007           poc = POC_MOVLW;
1008         while(size--){
1009           if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
1010             emitpcode(poc, popGet(AOP(IC_LEFT(ic)),offset));
1011             emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
1012           }
1013           emitpcode(POC_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset));
1014           emitSKPNC;
1015           emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
1016           emitpcode(POC_ADDWF,   popGet(AOP(IC_RESULT(ic)),offset));
1017           offset++;
1018         }
1019       }
1020     }
1021   }
1022
1023   if (AOP_SIZE(IC_RESULT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
1024     int sign =  !(SPEC_USIGN(getSpec(operandType(IC_LEFT(ic)))) |
1025                   SPEC_USIGN(getSpec(operandType(IC_RIGHT(ic)))) );
1026
1027
1028     /* Need to extend result to higher bytes */
1029     size = AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_RIGHT(ic)) - 1;
1030
1031     /* First grab the carry from the lower bytes */
1032     if (AOP_SIZE(IC_LEFT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
1033       int leftsize = AOP_SIZE(IC_LEFT(ic)) - AOP_SIZE(IC_RIGHT(ic));
1034       PIC_OPCODE poc = POC_MOVFW;
1035       if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
1036        (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
1037        (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
1038         poc = POC_MOVLW;
1039       while(leftsize-- > 0) {
1040         emitpcode(poc, popGet(AOP(IC_LEFT(ic)),offset));
1041         emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
1042         emitSKPNC;
1043         emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset));
1044         offset++;
1045         if (size)
1046           size--;
1047         else
1048           break;
1049       }
1050     } else {
1051       emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
1052       emitpcode(POC_RLF,  popGet(AOP(IC_RESULT(ic)),offset));
1053     }
1054
1055
1056     if(sign) {
1057       /* Now this is really horrid. Gotta check the sign of the addends and propogate
1058        * to the result */
1059
1060       emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_LEFT(ic)),offset-1,FALSE,FALSE),7,0));
1061       emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
1062       emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RIGHT(ic)),offset-1,FALSE,FALSE),7,0));
1063       emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
1064
1065       /* if chars or ints or being signed extended to longs: */
1066       if(size) {
1067         emitpcode(POC_MOVLW, popGetLit(0));
1068         emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE),7,0));
1069         emitpcode(POC_MOVLW, popGetLit(0xff));
1070       }
1071     }
1072
1073     offset++;
1074     while(size--) {
1075
1076       if(sign)
1077         emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
1078       else
1079         emitpcode(POC_CLRF,  popGet(AOP(IC_RESULT(ic)),offset));
1080
1081       offset++;
1082     }
1083   }
1084
1085
1086   //adjustArithmeticResult(ic);
1087
1088  release:
1089   freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
1090   freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
1091   freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
1092 }
1093
1094 /*-----------------------------------------------------------------*/
1095 /* genMinusDec :- does subtraction with decrement if possible     */
1096 /*-----------------------------------------------------------------*/
1097 bool genMinusDec (iCode *ic)
1098 {
1099     unsigned int icount ;
1100     unsigned int size = pic14_getDataSize(IC_RESULT(ic));
1101
1102     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1103     /* will try to generate an increment */
1104     /* if the right side is not a literal
1105     we cannot */
1106     if ((AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT) ||
1107         (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) ||
1108         (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) )
1109         return FALSE ;
1110
1111     DEBUGpic14_emitcode ("; lit val","%d",(unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit));
1112
1113     /* if the literal value of the right hand side
1114     is greater than 4 then it is not worth it */
1115     if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
1116         return FALSE ;
1117
1118     /* if decrement 16 bits in register */
1119     if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
1120         (size > 1) &&
1121         (icount == 1)) {
1122
1123       if(size == 2) {
1124         emitpcode(POC_DECF,    popGet(AOP(IC_RESULT(ic)),LSB));
1125         emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB));
1126         emitpcode(POC_INCF,    popGet(AOP(IC_RESULT(ic)),MSB16));
1127         emitpcode(POC_DECF,    popGet(AOP(IC_RESULT(ic)),MSB16));
1128
1129         pic14_emitcode("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
1130         pic14_emitcode("incfsz","%s,w",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
1131         pic14_emitcode(" decf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
1132       } else {
1133         /* size is 3 or 4 */
1134         emitpcode(POC_MOVLW,  popGetLit(0xff));
1135         emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),LSB));
1136         emitSKPNC;
1137         emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB16));
1138         emitSKPNC;
1139         emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB24));
1140
1141         pic14_emitcode("movlw","0xff");
1142         pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
1143
1144         emitSKPNC;
1145         pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
1146         emitSKPNC;
1147         pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE));
1148
1149         if(size > 3) {
1150           emitSKPNC;
1151           emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB32));
1152
1153           pic14_emitcode("skpnc","");
1154           emitSKPNC;
1155           pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE));
1156         }
1157
1158       }
1159
1160       return TRUE;
1161
1162     }
1163
1164     /* if the sizes are greater than 1 then we cannot */
1165     if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
1166         AOP_SIZE(IC_LEFT(ic)) > 1   )
1167         return FALSE ;
1168
1169     /* we can if the aops of the left & result match or
1170     if they are in registers and the registers are the
1171     same */
1172     if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
1173
1174       while (icount--)
1175         emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0));
1176
1177         //pic14_emitcode ("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
1178
1179         return TRUE ;
1180     }
1181
1182     DEBUGpic14_emitcode ("; returning"," result=%s, left=%s",
1183                    aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),
1184                    aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
1185     if(size==1) {
1186
1187       pic14_emitcode("decf","%s,w",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
1188       pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
1189
1190       emitpcode(POC_DECFW,  popGet(AOP(IC_LEFT(ic)),0));
1191       emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0));
1192
1193       return TRUE;
1194     }
1195
1196     return FALSE ;
1197 }
1198
1199 /*-----------------------------------------------------------------*/
1200 /* addSign - propogate sign bit to higher bytes                    */
1201 /*-----------------------------------------------------------------*/
1202 void addSign(operand *result, int offset, int sign)
1203 {
1204   int size = (pic14_getDataSize(result) - offset);
1205   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1206
1207   if(size > 0){
1208     if(sign && offset) {
1209
1210       if(size == 1) {
1211         emitpcode(POC_CLRF,popGet(AOP(result),offset));
1212         emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
1213         emitpcode(POC_DECF, popGet(AOP(result),offset));
1214       } else {
1215
1216         emitpcode(POC_MOVLW, popGetLit(0));
1217         emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
1218         emitpcode(POC_MOVLW, popGetLit(0xff));
1219         while(size--)
1220           emitpcode(POC_MOVWF, popGet(AOP(result),size));
1221
1222       }
1223     } else
1224       while(size--)
1225         emitpcode(POC_CLRF,popGet(AOP(result),offset++));
1226   }
1227 }
1228
1229 /*-----------------------------------------------------------------*/
1230 /* genMinusBits - generates code for subtraction  of two bits      */
1231 /*-----------------------------------------------------------------*/
1232 void genMinusBits (iCode *ic)
1233 {
1234     symbol *lbl = newiTempLabel(NULL);
1235     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1236     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
1237         pic14_emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
1238         pic14_emitcode("jnb","%s,%05d_DS_",AOP(IC_RIGHT(ic))->aopu.aop_dir,(lbl->key+100));
1239         pic14_emitcode("cpl","c");
1240         pic14_emitcode("","%05d_DS_:",(lbl->key+100));
1241         pic14_outBitC(IC_RESULT(ic));
1242     }
1243     else{
1244         pic14_emitcode("mov","c,%s",AOP(IC_RIGHT(ic))->aopu.aop_dir);
1245         pic14_emitcode("subb","a,acc");
1246         pic14_emitcode("jnb","%s,%05d_DS_",AOP(IC_LEFT(ic))->aopu.aop_dir,(lbl->key+100));
1247         pic14_emitcode("inc","a");
1248         pic14_emitcode("","%05d_DS_:",(lbl->key+100));
1249         aopPut(AOP(IC_RESULT(ic)),"a",0);
1250         addSign(IC_RESULT(ic), MSB16, SPEC_USIGN(getSpec(operandType(IC_RESULT(ic)))));
1251     }
1252 }
1253
1254 /*-----------------------------------------------------------------*/
1255 /* genMinus - generates code for subtraction                       */
1256 /*-----------------------------------------------------------------*/
1257 void genMinus (iCode *ic)
1258 {
1259   int size, offset = 0, same=0;
1260   unsigned long lit = 0L;
1261
1262   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1263   aopOp (IC_LEFT(ic),ic,FALSE);
1264   aopOp (IC_RIGHT(ic),ic,FALSE);
1265   aopOp (IC_RESULT(ic),ic,TRUE);
1266
1267   if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY  &&
1268       AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
1269     operand *t = IC_RIGHT(ic);
1270     IC_RIGHT(ic) = IC_LEFT(ic);
1271     IC_LEFT(ic) = t;
1272   }
1273
1274   DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
1275                    AopType(AOP_TYPE(IC_RESULT(ic))),
1276                    AopType(AOP_TYPE(IC_LEFT(ic))),
1277                    AopType(AOP_TYPE(IC_RIGHT(ic))));
1278
1279   /* special cases :- */
1280   /* if both left & right are in bit space */
1281   if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
1282       AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
1283     genPlusBits (ic);
1284     goto release ;
1285   }
1286
1287   /* if I can do an decrement instead
1288      of subtract then GOOD for ME */
1289   //  if (genMinusDec (ic) == TRUE)
1290   //    goto release;
1291
1292   size = pic14_getDataSize(IC_RESULT(ic));
1293   same = pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)));
1294
1295   if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
1296     /* Add a literal to something else */
1297
1298     lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
1299     lit = - (long)lit;
1300
1301     genAddLit ( ic,  lit);
1302
1303 #if 0
1304     /* add the first byte: */
1305     pic14_emitcode("movlw","0x%x", lit & 0xff);
1306     pic14_emitcode("addwf","%s,f", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
1307     emitpcode(POC_MOVLW,  popGetLit(lit & 0xff));
1308     emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),0));
1309
1310
1311     offset = 1;
1312     size--;
1313
1314     while(size-- > 0) {
1315
1316       lit >>= 8;
1317
1318       if(lit & 0xff) {
1319
1320         if((lit & 0xff) == 0xff) {
1321           emitpcode(POC_MOVLW,  popGetLit(0xff));
1322           emitSKPC;
1323           emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset));
1324         } else {
1325           emitpcode(POC_MOVLW,  popGetLit(lit & 0xff));
1326           emitSKPNC;
1327           emitpcode(POC_MOVLW,  popGetLit((lit+1) & 0xff));
1328           emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset));
1329         }
1330
1331       } else {
1332         /* do the rlf known zero trick here */
1333         emitpcode(POC_MOVLW,  popGetLit(1));
1334         emitSKPNC;
1335         emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset));
1336       }
1337       offset++;
1338     }
1339 #endif
1340   } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
1341     // bit subtraction
1342
1343     pic14_emitcode(";bitsub","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
1344     pic14_emitcode(";bitsub","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
1345     pic14_emitcode(";bitsub","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
1346
1347     /* here we are subtracting a bit from a char or int */
1348     if(size == 1) {
1349       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
1350
1351         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
1352         emitpcode(POC_DECF ,  popGet(AOP(IC_RESULT(ic)),0));
1353
1354         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
1355                  AOP(IC_RIGHT(ic))->aopu.aop_dir,
1356                  AOP(IC_RIGHT(ic))->aopu.aop_dir);
1357         pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
1358       } else {
1359
1360         if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
1361           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
1362           emitpcode(POC_XORLW , popGetLit(1));
1363         }else  if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
1364               (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
1365
1366           lit = (unsigned long)floatFromVal(AOP(IC_LEFT(ic))->aopu.aop_lit);
1367
1368           if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
1369             if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
1370               if(lit & 1) {
1371                 emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0));
1372                 emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0));
1373               }
1374             }else{
1375               emitpcode(POC_BCF ,     popGet(AOP(IC_RESULT(ic)),0));
1376               if(lit & 1)
1377                 emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0));
1378               else
1379                 emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
1380               emitpcode(POC_BSF ,     popGet(AOP(IC_RESULT(ic)),0));
1381             }
1382             goto release;
1383           } else {
1384             emitpcode(POC_MOVLW , popGetLit(lit & 0xff));
1385             emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
1386             emitpcode(POC_MOVLW , popGetLit((lit-1) & 0xff));
1387             emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
1388
1389           }
1390
1391         } else {
1392           emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
1393           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
1394           emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0));
1395         }
1396
1397         if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
1398
1399           emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0));
1400
1401         } else  {
1402           emitpcode(POC_ANDLW , popGetLit(1));
1403 /*
1404           emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
1405           emitSKPZ;
1406           emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
1407 */
1408         }
1409
1410       }
1411
1412     }
1413   } else   if(// (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
1414               (AOP(IC_LEFT(ic))->type == AOP_LIT) &&
1415               (AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)) {
1416
1417     lit = (unsigned long)floatFromVal(AOP(IC_LEFT(ic))->aopu.aop_lit);
1418     DEBUGpic14_emitcode ("; left is lit","line %d result %s, left %s, right %s",__LINE__,
1419                    AopType(AOP_TYPE(IC_RESULT(ic))),
1420                    AopType(AOP_TYPE(IC_LEFT(ic))),
1421                    AopType(AOP_TYPE(IC_RIGHT(ic))));
1422
1423
1424     if( (size == 1) && ((lit & 0xff) == 0) ) {
1425       /* res = 0 - right */
1426       if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
1427         emitpcode(POC_COMF,  popGet(AOP(IC_RIGHT(ic)),0));
1428         emitpcode(POC_INCF,  popGet(AOP(IC_RIGHT(ic)),0));
1429       } else {
1430         emitpcode(POC_COMFW,  popGet(AOP(IC_RIGHT(ic)),0));
1431         emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0));
1432         emitpcode(POC_INCF,   popGet(AOP(IC_RESULT(ic)),0));
1433       }
1434       goto release;
1435     }
1436
1437     emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),0));
1438     emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
1439     emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
1440
1441
1442     offset = 1;
1443     while(--size) {
1444       lit >>= 8;
1445
1446       if(size == 1) {
1447         /* This is the last byte in a multibyte subtraction
1448          * There are a couple of tricks we can do by not worrying about
1449          * propogating the carry */
1450         if(lit == 0xff) {
1451           /* 0xff - x == ~x */
1452           if(same) {
1453             emitpcode(POC_COMF,  popGet(AOP(IC_RESULT(ic)),offset));
1454             emitSKPC;
1455             emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
1456           } else {
1457             emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset));
1458             emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
1459             emitSKPC;
1460             emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
1461           }
1462         } else {
1463             emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
1464             emitSKPC;
1465             emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset));
1466             emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
1467             emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
1468         }
1469
1470         goto release;
1471       }
1472
1473       if(same) {
1474
1475         if(lit & 0xff) {
1476           emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
1477           emitSKPC;
1478           emitpcode(POC_MOVLW, popGetLit((lit & 0xff)-1));
1479           emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
1480         } else {
1481           emitSKPNC;
1482           emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
1483
1484         }
1485       } else {
1486
1487         if(lit & 0xff) {
1488           emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
1489           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
1490         } else
1491           emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
1492
1493         emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),offset));
1494         emitSKPC;
1495         emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
1496         emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
1497       }
1498     }
1499
1500
1501   } else {
1502
1503     DEBUGpic14_emitcode ("; ","line %d result %s, left %s, right %s",__LINE__,
1504                    AopType(AOP_TYPE(IC_RESULT(ic))),
1505                    AopType(AOP_TYPE(IC_LEFT(ic))),
1506                    AopType(AOP_TYPE(IC_RIGHT(ic))));
1507
1508     if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
1509       DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1510       emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
1511       emitpcode(POC_SUBLW, popGetLit(0));
1512       emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
1513     } else {
1514
1515       if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
1516         emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
1517         emitpcode(POC_SUBLW, popGetLit(0));
1518         if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
1519           emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
1520       } else {
1521
1522         DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
1523         if(AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)
1524           emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
1525
1526         if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
1527           emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0));
1528         else {
1529           if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
1530               (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
1531             emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0));
1532           } else {
1533             emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0));
1534           }
1535           if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
1536             if ( AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
1537               emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0));
1538               emitSKPZ;
1539               emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0));
1540             }else
1541               emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
1542           }
1543         }
1544       }
1545     }
1546
1547     size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
1548     offset = 1;
1549
1550     if(size){
1551       if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)))) {
1552         if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
1553           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
1554           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE))) {
1555           while(size--){
1556             emitpcode(POC_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset));
1557             emitSKPC;
1558             emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
1559             emitpcode(POC_SUBLW,   popGet(AOP(IC_LEFT(ic)),offset));
1560             emitpcode(POC_MOVWF,   popGet(AOP(IC_RESULT(ic)),offset));
1561             offset++;
1562           }
1563         } else {
1564           while(size--){
1565             emitpcode(POC_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset));
1566             emitSKPC;
1567             emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
1568             emitpcode(POC_SUBFW,   popGet(AOP(IC_LEFT(ic)),offset));
1569             emitpcode(POC_MOVWF,   popGet(AOP(IC_RESULT(ic)),offset));
1570             offset++;
1571           }
1572         }
1573       } else {
1574         PIC_OPCODE poc = POC_MOVFW;
1575         if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
1576           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
1577           (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
1578           poc = POC_MOVLW;
1579       while(size--){
1580           if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
1581             emitpcode(POC_MOVFW,  popGet(AOP(IC_LEFT(ic)),offset));
1582             emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),offset));
1583           }
1584           emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),offset));
1585           emitSKPC;
1586           emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
1587           emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
1588           offset++;
1589         }
1590       }
1591     }
1592   }
1593
1594   //    adjustArithmeticResult(ic);
1595
1596  release:
1597   freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
1598   freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
1599   freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
1600 }
1601 /*-----------------------------------------------------------------*
1602  * genUMult8XLit_16 - unsigned multiplication of two 8-bit numbers.
1603  *
1604  *
1605  *-----------------------------------------------------------------*/
1606 void genUMult8XLit_16 (operand *left,
1607                        operand *right,
1608                        operand *result,
1609                        pCodeOpReg *result_hi)
1610
1611 {
1612
1613   unsigned int lit;
1614   unsigned int i,have_first_bit;
1615   int same;
1616   pCodeOp *temp;
1617
1618   if (AOP_TYPE(right) != AOP_LIT){
1619     fprintf(stderr,"%s %d - right operand is not a literal\n",__FILE__,__LINE__);
1620     exit(1);
1621   }
1622
1623
1624   if(!result_hi) {
1625     result_hi = PCOR(popGet(AOP(result),1));
1626   }
1627
1628   lit = (unsigned int)floatFromVal(AOP(right)->aopu.aop_lit);
1629   lit &= 0xff;
1630   pic14_emitcode(";","Unrolled 8 X 8 multiplication");
1631
1632   same = pic14_sameRegs(AOP(left), AOP(result));
1633
1634   if(same) {
1635     switch(lit) {
1636     case 0:
1637       emitpcode(POC_CLRF,  popGet(AOP(left),0));
1638       return;
1639     case 2:
1640       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1641       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1642       return;
1643     case 3:
1644       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1645       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1646       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1647       return;
1648     case 4:
1649       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1650       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1651       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1652       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1653       return;
1654     case 5:
1655       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1656       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1657       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1658       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 5*F
1659       return;
1660     case 6:
1661       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1662       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1663       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1664       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1665       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1666       return;
1667     case 7:
1668       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1669       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1670       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1671       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 5*F
1672       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 7*F
1673       return;
1674     case 8:
1675       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1676       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1677       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1678       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 5*F
1679       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 8*F
1680       return;
1681     case 9:
1682       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1683       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1684       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1685       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1686       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1687       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1688       return;
1689     case 10:
1690       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1691       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1692       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1693       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 5*F
1694       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1695       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1696       return;
1697     case 11:
1698       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1699       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1700       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1701       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 5*F
1702       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 8*F
1703       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 11*F
1704       return;
1705     case 12:
1706       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1707       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1708       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1709       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1710       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1711       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1712       emitpcode(POC_ADDWF, popGet(AOP(left),0));
1713       return;
1714     case 13:
1715       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1716       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1717       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1718       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 5*F
1719       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 8*F
1720       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 13*F
1721       return;
1722     case 14:
1723       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1724       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 2*F
1725       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 3*F
1726       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 5*F
1727       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 8*F
1728       emitpcode(POC_ADDFW, popGet(AOP(left),0));  // W = 11*F
1729       emitpcode(POC_ADDWF, popGet(AOP(left),0));  // F = 14*F
1730       return;
1731     case 15:
1732       temp = popGetTempReg();
1733       if(!temp) {
1734         fprintf(stderr,"ERROR: unable to allocate register. %s:%d\n",__FUNCTION__,__LINE__);
1735         exit(1);
1736       }
1737       emitpcode(POC_SWAPFW, popGet(AOP(left),0));
1738       emitpcode(POC_MOVWF,  temp);
1739       emitpcode(POC_ANDLW,  popGetLit(0xf0));
1740       emitpcode(POC_MOVWF,  popGet(AOP(left),0));
1741       emitpcode(POC_SWAPFW, temp);
1742       emitpcode(POC_SUBWF,  popGet(AOP(left),0));
1743       popReleaseTempReg(temp);
1744       return;
1745     case 16:
1746       emitpcode(POC_SWAPFW, popGet(AOP(left),0));
1747       emitpcode(POC_ANDLW,  popGetLit(0xf0));
1748       emitpcode(POC_MOVWF,  popGet(AOP(left),0));
1749       return;
1750     case 17:
1751       emitpcode(POC_SWAPFW, popGet(AOP(left),0));
1752       emitpcode(POC_ANDLW,  popGetLit(0xf0));
1753       emitpcode(POC_ADDWF,  popGet(AOP(left),0));
1754       return;
1755     case 32:
1756       emitpcode(POC_SWAPF,  popGet(AOP(left),0));
1757       emitpcode(POC_RLFW,   popGet(AOP(left),0));
1758       emitpcode(POC_ANDLW,  popGetLit(0xe0));
1759       emitpcode(POC_MOVWF,  popGet(AOP(left),0));
1760       return;
1761     case 64:
1762       emitpcode(POC_SWAPF,  popGet(AOP(left),0));
1763       emitpcode(POC_RLF,    popGet(AOP(left),0));
1764       emitpcode(POC_RLFW,   popGet(AOP(left),0));
1765       emitpcode(POC_ANDLW,  popGetLit(0xc0));
1766       emitpcode(POC_MOVWF,  popGet(AOP(left),0));
1767       return;
1768     case 128:
1769       emitpcode(POC_RRFW,   popGet(AOP(left),0));
1770       emitpcode(POC_CLRF,   popGet(AOP(left),0));
1771       emitpcode(POC_RRF,    popGet(AOP(left),0));
1772       return;
1773
1774     }
1775   } else {
1776
1777     switch(lit) {
1778     case 0:
1779       emitpcode(POC_CLRF,  popGet(AOP(result),0));
1780       emitpcode(POC_CLRF,  popCopyReg(result_hi));
1781       return;
1782     case 2:
1783       emitpcode(POC_MOVFW, popGet(AOP(left),0));
1784       emitpcode(POC_MOVWF, popGet(AOP(result),0));
1785       emitpcode(POC_ADDWF, popGet(AOP(result),0));
1786       emitpcode(POC_CLRF,  popCopyReg(result_hi));
1787       emitpcode(POC_RLF,   popCopyReg(result_hi));
1788       return;
1789     }
1790
1791   }
1792
1793   emitpcode(POC_MOVFW, popGet(AOP(left),0));
1794   emitpcode(POC_CLRF,  popGet(AOP(result),0));
1795   emitpcode(POC_CLRF,  popCopyReg(result_hi));
1796
1797   have_first_bit = 0;
1798   for(i=0; i<8; i++) {
1799
1800     if(lit & 1) {
1801       emitpcode(POC_ADDWF, popCopyReg(result_hi));
1802       have_first_bit = 1;
1803     }
1804
1805     if(have_first_bit) {
1806       emitpcode(POC_RRF,   popCopyReg(result_hi));
1807       emitpcode(POC_RRF,   popGet(AOP(result),0));
1808     }
1809
1810     lit >>= 1;
1811   }
1812
1813 }
1814
1815 /*-----------------------------------------------------------------*
1816  * genUMult8X8_16 - unsigned multiplication of two 8-bit numbers.
1817  *
1818  *
1819  *-----------------------------------------------------------------*/
1820 void genUMult8X8_16 (operand *left,
1821                      operand *right,
1822                      operand *result,
1823                      pCodeOpReg *result_hi)
1824
1825 {
1826
1827   int i;
1828   int looped = 1;
1829
1830   if(!result_hi) {
1831     result_hi = PCOR(popGet(AOP(result),1));
1832   }
1833
1834   if (AOP_TYPE(right) == AOP_LIT) {
1835     genUMult8XLit_16(left,right,result,result_hi);
1836     return;
1837   }
1838
1839   if(!looped) {
1840     pic14_emitcode(";","Unrolled 8 X 8 multiplication");
1841
1842     emitpcode(POC_MOVFW, popGet(AOP(right),0));
1843     emitpcode(POC_CLRF,  popGet(AOP(result),0));
1844     emitpcode(POC_CLRF,  popCopyReg(result_hi));
1845     emitCLRC;
1846
1847     for(i=0; i<8; i++) {
1848       emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),i,0));
1849       emitpcode(POC_ADDWF, popCopyReg(result_hi));
1850       emitpcode(POC_RRF,   popCopyReg(result_hi));
1851       emitpcode(POC_RRF,   popGet(AOP(result),0));
1852     }
1853
1854
1855     /*
1856       Here's another version that does the same thing and takes the
1857       same number of instructions. The one above is slightly better
1858       because the entry instructions have a higher probability of
1859       being optimized out.
1860     */
1861     /*
1862       emitpcode(POC_CLRF,  popCopyReg(result_hi));
1863       emitpcode(POC_RRFW,  popGet(AOP(left),0));
1864       emitpcode(POC_MOVWF, popGet(AOP(result),0));
1865       emitpcode(POC_MOVFW, popGet(AOP(right),0));
1866
1867       for(i=0; i<8; i++) {
1868       emitSKPNC;
1869       emitpcode(POC_ADDWF, popCopyReg(result_hi));
1870       emitpcode(POC_RRF,   popCopyReg(result_hi));
1871       emitpcode(POC_RRF,   popGet(AOP(result),0));
1872       }
1873     */
1874
1875   } else {
1876     symbol  *tlbl = newiTempLabel(NULL);
1877     pCodeOp *temp;
1878
1879
1880     pic14_emitcode(";","Looped 8 X 8 multiplication");
1881
1882     emitpcode(POC_CLRF,  popGet(AOP(result),0));
1883     emitpcode(POC_CLRF,  popCopyReg(result_hi));
1884
1885     emitpcode(POC_BSF,   newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE),7,0));
1886
1887     emitpcode(POC_MOVFW, popGet(AOP(right),0));
1888
1889     temp = popGetTempReg();
1890     emitpcode(POC_MOVWF, popCopyReg(PCOR(temp)));
1891
1892     emitpcode(POC_MOVFW, popGet(AOP(left),0));
1893
1894     emitpLabel(tlbl->key);
1895
1896     emitpcode(POC_RRF,   popCopyReg(PCOR(temp)));
1897     emitSKPNC;
1898     emitpcode(POC_ADDWF, popCopyReg(result_hi));
1899
1900     emitpcode(POC_RRF,   popCopyReg(result_hi));
1901     emitpcode(POC_RRF,   popGet(AOP(result),0));
1902
1903     emitSKPC;
1904     emitpcode(POC_GOTO,  popGetLabel(tlbl->key));
1905
1906     popReleaseTempReg(temp);
1907
1908   }
1909 }
1910
1911 /*-----------------------------------------------------------------*
1912  * genSMult8X8_16 - signed multiplication of two 8-bit numbers
1913  *
1914  *  this routine will call the unsigned multiply routine and then
1915  * post-fix the sign bit.
1916  *-----------------------------------------------------------------*/
1917 void genSMult8X8_16 (operand *left,
1918                      operand *right,
1919                      operand *result,
1920                      pCodeOpReg *result_hi)
1921 {
1922
1923   if(!result_hi) {
1924     result_hi = PCOR(popGet(AOP(result),1));
1925   }
1926
1927   genUMult8X8_16(left,right,result,result_hi);
1928
1929   emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),7,0));
1930   emitpcode(POC_SUBWF, popCopyReg(result_hi));
1931   emitpcode(POC_MOVFW, popGet(AOP(left),0));
1932   emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),7,0));
1933   emitpcode(POC_SUBWF, popGet(AOP(result),1));
1934
1935 }
1936
1937 /*-----------------------------------------------------------------*
1938  * genMult8X8_8 - multiplication of two 8-bit numbers
1939  *
1940  *  this routine will call the unsigned multiply 8X8=>16 routine and
1941  * then throw away the high byte of the result.
1942  *
1943  *-----------------------------------------------------------------*/
1944 void genMult8X8_8 (operand *left,
1945                    operand *right,
1946                    operand *result)
1947 {
1948   pCodeOp *result_hi = popGetTempReg();
1949
1950   if (AOP_TYPE(right) == AOP_LIT)
1951     genUMult8XLit_16(left,right,result,PCOR(result_hi));
1952   else
1953     genUMult8X8_16(left,right,result,PCOR(result_hi));
1954
1955   popReleaseTempReg(result_hi);
1956 }
1957 #if 0
1958 /*-----------------------------------------------------------------*/
1959 /* constMult - generates code for multiplication by a constant     */
1960 /*-----------------------------------------------------------------*/
1961 void genMultConst(unsigned C)
1962 {
1963
1964   unsigned lit;
1965   unsigned sr3; // Shift right 3
1966   unsigned mask;
1967
1968   int size = 1;
1969
1970   /*
1971     Convert a string of 3 binary 1's in the lit into
1972     0111 = 1000 - 1;
1973   */
1974
1975   mask = 7 << ( (size*8) - 3);
1976   lit = C;
1977   sr3 = 0;
1978
1979   while(mask < (1<<size*8)) {
1980
1981     if( (mask & lit) == lit) {
1982       unsigned lsb;
1983
1984       /* We found 3 (or more) consecutive 1's */
1985
1986       lsb = mask & ~(mask & (mask-1));  // lsb of mask.
1987
1988       consecutive_bits = ((lit + lsb) & lit) ^ lit;
1989
1990       lit ^= consecutive_bits;
1991
1992       mask <<= 3;
1993
1994       sr3 |= (consecutive + lsb);
1995
1996     }
1997
1998     mask >>= 1;
1999
2000   }
2001
2002 }
2003
2004 #endif